diff --git a/CMakeLists.txt b/CMakeLists.txt index 8b5bf385e9572f8c9ed5eecf869fdf270ce44b52..1d7a9fe5065bd9cc64cdd1ac45b349a7572db3c4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,7 +14,7 @@ project(scalfmm) ENABLE_LANGUAGE(CXX ) # Options -OPTION( SCALFMM_USE_CBLAS "Set to ON to build ScaFMM with BLAS" OFF ) +OPTION( SCALFMM_USE_CBLAS "Set to ON to build ScaFMM with BLAS" ON ) OPTION( SCALFMM_USE_MPI "Set to ON to build ScaFMM with MPI" OFF ) OPTION( SCALFMM_USE_TRACE "Set to ON to print trace or use itac trace" OFF ) OPTION( SCALFMM_BUILD_TESTS "Set to ON to build fonctionnalities Tests" ON ) diff --git a/Data/test20k.bin.fma b/Data/test20k.bin.fma new file mode 100644 index 0000000000000000000000000000000000000000..ea8824cc468a62dbdc75bad9dbc52620a504d7a0 Binary files /dev/null and b/Data/test20k.bin.fma differ diff --git a/Licence.txt b/Licence.txt index 671f482d3cfd32c8a5ba4a08b8f39461dbc4da2a..5b1cb77af92aafc47382cc0620d93c1cf353425c 100644 --- a/Licence.txt +++ b/Licence.txt @@ -1,3 +1,13 @@ +Logiciel initial: ScalFmm Version 0.5 +Co-auteurs : Olivier Coulaud, Bérenger Bramas. +Propriétaires : INRIA. +Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +Initial software: ScalFmm Version 0.5 +Co-authors: Olivier Coulaud, Bérenger Bramas. +Owners: INRIA. +Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. + + Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que la communauté scientifique l'utilise afin de le tester et de l'évaluer. Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation dans un but lucratif ou à des fins commerciales est interdite sauf autorisation expresse et préalable d'Inria. diff --git a/Src/Arranger/FOctreeArranger.hpp b/Src/Arranger/FOctreeArranger.hpp index bdb1229b59c73b86d5315f56b38a88fefcf74b59..205419597c2700e5de63a9a1d4507afe6d5f600d 100644 --- a/Src/Arranger/FOctreeArranger.hpp +++ b/Src/Arranger/FOctreeArranger.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FOCTREEARRANGER_HPP #define FOCTREEARRANGER_HPP diff --git a/Src/Arranger/FOctreeArrangerProc.hpp b/Src/Arranger/FOctreeArrangerProc.hpp index f6b868aeacaf881d0e8a72e31aaf71add91f3614..146927ee89712fedc7c786769375d710118ba787 100644 --- a/Src/Arranger/FOctreeArrangerProc.hpp +++ b/Src/Arranger/FOctreeArrangerProc.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FOCTREEARRANGERPROC_HPP #define FOCTREEARRANGERPROC_HPP diff --git a/Src/Components/FAbstractCell.hpp b/Src/Components/FAbstractCell.hpp index 224b12a193c86dfcb9b0b31b20069b815c33e8d8..93b2292c79970d7d0e7ed038bfb3ea5db7c903b9 100644 --- a/Src/Components/FAbstractCell.hpp +++ b/Src/Components/FAbstractCell.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FABSTRACTCELL_HPP #define FABSTRACTCELL_HPP diff --git a/Src/Components/FAbstractKernels.hpp b/Src/Components/FAbstractKernels.hpp index f1a03f2e6543d4642d5804ac6009ec7b3ffd75d0..cd89e9f764451b65a50be559e0ab68ea419dd45f 100644 --- a/Src/Components/FAbstractKernels.hpp +++ b/Src/Components/FAbstractKernels.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FABSTRACTKERNELS_HPP #define FABSTRACTKERNELS_HPP diff --git a/Src/Components/FAbstractLeaf.hpp b/Src/Components/FAbstractLeaf.hpp index 8f63ddb391ff11a8196d54a4076da4b71c3de9ac..4466970dfee2949d53c7b772b91eae004ae36827 100644 --- a/Src/Components/FAbstractLeaf.hpp +++ b/Src/Components/FAbstractLeaf.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FABSTRACTLEAF_HPP #define FABSTRACTLEAF_HPP diff --git a/Src/Components/FAbstractParticle.hpp b/Src/Components/FAbstractParticle.hpp index 504bcf05d5efd9ea730604c56c849ee024391903..01ef72448461a0e1a5403a5ebbdba043b76d98aa 100644 --- a/Src/Components/FAbstractParticle.hpp +++ b/Src/Components/FAbstractParticle.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FABSTRACTPARTICLE_HPP #define FABSTRACTPARTICLE_HPP diff --git a/Src/Components/FBasicCell.hpp b/Src/Components/FBasicCell.hpp index b7d5cfe3f4dd115bdb57f3bb6de36cd4442b47c2..c6b1885b000f560b4417aeb2d816ef3efcd4e0a7 100644 --- a/Src/Components/FBasicCell.hpp +++ b/Src/Components/FBasicCell.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FBASICCELL_HPP #define FBASICCELL_HPP diff --git a/Src/Components/FBasicKernels.hpp b/Src/Components/FBasicKernels.hpp index d552e375549ca490941984d0180a8e4808799c3d..8a8bf31d6d07cd8a0711270bff34b3546ea583f2 100644 --- a/Src/Components/FBasicKernels.hpp +++ b/Src/Components/FBasicKernels.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FBASICKERNELS_HPP #define FBASICKERNELS_HPP diff --git a/Src/Components/FBasicParticle.hpp b/Src/Components/FBasicParticle.hpp index 046d8ca7b4fb4f3d01c359d8c5509445c94f9e7c..a7d0b69e78384e569903ff5966c3d18d6fc9fa34 100644 --- a/Src/Components/FBasicParticle.hpp +++ b/Src/Components/FBasicParticle.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FBASICPARTICLE_HPP #define FBASICPARTICLE_HPP diff --git a/Src/Components/FFmaParticle.hpp b/Src/Components/FFmaParticle.hpp index 04b2c0bcb3bf30c01c04cb1acd22a7af0d607f8c..21b350070b2f308e69ae4ea73c85e126239570aa 100644 --- a/Src/Components/FFmaParticle.hpp +++ b/Src/Components/FFmaParticle.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFmaPARTICLE_HPP #define FFmaPARTICLE_HPP diff --git a/Src/Components/FSimpleLeaf.hpp b/Src/Components/FSimpleLeaf.hpp index 8b044bca410ec01649c4e85dac5fa4773eb65dcc..beb3895a93e777e890e43ce166654e02ccae1ca1 100644 --- a/Src/Components/FSimpleLeaf.hpp +++ b/Src/Components/FSimpleLeaf.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FSIMPLELEAF_HPP #define FSIMPLELEAF_HPP diff --git a/Src/Components/FTestCell.hpp b/Src/Components/FTestCell.hpp index fcff639a771c6308f414b0ad487e82b39b615908..cfb6db2ed732c2afe15d8f085dea7ffdba36d0b9 100644 --- a/Src/Components/FTestCell.hpp +++ b/Src/Components/FTestCell.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTESTCELL_HPP #define FTESTCELL_HPP diff --git a/Src/Components/FTestKernels.hpp b/Src/Components/FTestKernels.hpp index b1f8d06553ac03472154b3df37d6507f5183e373..611a2abd1004997d91ddec043f3a53a7fba7bec2 100644 --- a/Src/Components/FTestKernels.hpp +++ b/Src/Components/FTestKernels.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTESTKERNELS_HPP #define FTESTKERNELS_HPP diff --git a/Src/Components/FTestParticle.hpp b/Src/Components/FTestParticle.hpp index fb304810f4a44159c0ae6a270a9784a5bb168778..12c9bf3f736b378d58099eef7347f2fd53c1c6b4 100644 --- a/Src/Components/FTestParticle.hpp +++ b/Src/Components/FTestParticle.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTESTPARTICLE_HPP #define FTESTPARTICLE_HPP diff --git a/Src/Components/FTestPeriodicKernels.hpp b/Src/Components/FTestPeriodicKernels.hpp index adfe4a6963bc155e5e43cada07c78ac91682932d..4da86c2a2ab0a55ca05719db0cb0c11a7f535555 100644 --- a/Src/Components/FTestPeriodicKernels.hpp +++ b/Src/Components/FTestPeriodicKernels.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTESTPERIODICKERNELS_HPP #define FTESTPERIODICKERNELS_HPP diff --git a/Src/Components/FTypedLeaf.hpp b/Src/Components/FTypedLeaf.hpp index 3a31bc02d04baae46010a5150a10a75cf51bf2fc..0e0740e4f572c8c687a4b99a5489e44831b1f72b 100644 --- a/Src/Components/FTypedLeaf.hpp +++ b/Src/Components/FTypedLeaf.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTYPEDLEAF_HPP #define FTYPEDLEAF_HPP diff --git a/Src/Containers/FBoolArray.hpp b/Src/Containers/FBoolArray.hpp index 7a7c405bf5cfa1af755055e0014e4342ddc3e278..ef08d9875f66358abe65d2aa8029ea5c0f595741 100644 --- a/Src/Containers/FBoolArray.hpp +++ b/Src/Containers/FBoolArray.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FBOOLARRAY_HPP #define FBOOLARRAY_HPP diff --git a/Src/Containers/FLightOctree.hpp b/Src/Containers/FLightOctree.hpp index c19fe4de0b355d070c5810ffd6710693b64f3ba0..42c3f99cf39d3a1d9c4aed541a48e30745126269 100644 --- a/Src/Containers/FLightOctree.hpp +++ b/Src/Containers/FLightOctree.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FLIGHTOCTREE_HPP #define FLIGHTOCTREE_HPP diff --git a/Src/Containers/FList.hpp b/Src/Containers/FList.hpp index a72ac353a4ce5b2db9741efd20337f3929ce3920..ea88ee0e8b7368977d333380a490d30b0576b287 100644 --- a/Src/Containers/FList.hpp +++ b/Src/Containers/FList.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FLIST_HPP #define FLIST_HPP diff --git a/Src/Containers/FOctree.hpp b/Src/Containers/FOctree.hpp index 8cce218c0f14ed3c2f984da07446ec6abe0f4aaf..c9c97b22357e5e673ad604cbd368774aa26c68ea 100644 --- a/Src/Containers/FOctree.hpp +++ b/Src/Containers/FOctree.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FOCTREE_HPP #define FOCTREE_HPP diff --git a/Src/Containers/FSubOctree.hpp b/Src/Containers/FSubOctree.hpp index 6f2c4a0b1bfb8894e687d3300b81d2bc1637374c..687dfe6488baaca45f8eebdc39dde47f3bb9d276 100644 --- a/Src/Containers/FSubOctree.hpp +++ b/Src/Containers/FSubOctree.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FSUBOCTREE_HPP #define FSUBOCTREE_HPP diff --git a/Src/Containers/FTreeCoordinate.hpp b/Src/Containers/FTreeCoordinate.hpp index 2f0480d1460dfd67082a2c90a5d06bcf4fae7f44..ae459fd679861802d049659738d15f47223a3ce2 100644 --- a/Src/Containers/FTreeCoordinate.hpp +++ b/Src/Containers/FTreeCoordinate.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTREECOORDINATE_HPP #define FTREECOORDINATE_HPP diff --git a/Src/Containers/FVector.hpp b/Src/Containers/FVector.hpp index 3b05e1bb0167606d6fcaed49d1b3c0aa4980e60f..d7412b84eca0f80d4c21ac17c02aa69032ab2d1e 100644 --- a/Src/Containers/FVector.hpp +++ b/Src/Containers/FVector.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FVECTOR_HPP #define FVECTOR_HPP diff --git a/Src/Core/FFmmAlgorithm.hpp b/Src/Core/FFmmAlgorithm.hpp index 099ffdff7501c9e6e26d8941596e03733fe188e2..90afff093bb1d09f3214450e812dead17416fe60 100644 --- a/Src/Core/FFmmAlgorithm.hpp +++ b/Src/Core/FFmmAlgorithm.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMMALGORITHM_HPP #define FFMMALGORITHM_HPP diff --git a/Src/Core/FFmmAlgorithmPeriodic.hpp b/Src/Core/FFmmAlgorithmPeriodic.hpp index 0974ed766fa870d700ee0ba74708124a5326b91e..f478866bd7100a0e76fe45f1f38ca84733c22eb0 100644 --- a/Src/Core/FFmmAlgorithmPeriodic.hpp +++ b/Src/Core/FFmmAlgorithmPeriodic.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMMALGORITHMPERIODIC_HPP #define FFMMALGORITHMPERIODIC_HPP diff --git a/Src/Core/FFmmAlgorithmTask.hpp b/Src/Core/FFmmAlgorithmTask.hpp index daee348d8bc9624c3e0da082ded3dee33f5cafd2..72281b32ebdfb3e98e323796030054c29e0f39fd 100644 --- a/Src/Core/FFmmAlgorithmTask.hpp +++ b/Src/Core/FFmmAlgorithmTask.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMMALGORITHMTASK_HPP #define FFMMALGORITHMTASK_HPP diff --git a/Src/Core/FFmmAlgorithmThread.hpp b/Src/Core/FFmmAlgorithmThread.hpp index f2dc8d5629e250bd9ec8c66527eed5102b742c78..d8b7fa74bb53291d673196c6a62bfb8246800519 100644 --- a/Src/Core/FFmmAlgorithmThread.hpp +++ b/Src/Core/FFmmAlgorithmThread.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMMALGORITHMTHREAD_HPP #define FFMMALGORITHMTHREAD_HPP diff --git a/Src/Core/FFmmAlgorithmThreadProc.hpp b/Src/Core/FFmmAlgorithmThreadProc.hpp index a0dea032c3d2f93633f35c54be4447c8b299cc27..60be53118f94e11c5b8f8136f74d85ece39f5e18 100644 --- a/Src/Core/FFmmAlgorithmThreadProc.hpp +++ b/Src/Core/FFmmAlgorithmThreadProc.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMMALGORITHMTHREADPROC_HPP #define FFMMALGORITHMTHREADPROC_HPP @@ -570,15 +565,12 @@ private: MPI_Status status[2 * nbProcess * OctreeHeight]; int iterRequest = 0; - struct CellToSend{ - MortonIndex index; - char data[CellClass::SerializedSizeUp]; - }; + const int SizeOfCellToSend = sizeof(MortonIndex) + CellClass::SerializedSizeUp; - CellToSend* sendBuffer[nbProcess * OctreeHeight]; + char* sendBuffer[nbProcess * OctreeHeight]; memset(sendBuffer, 0, sizeof(CellClass*) * nbProcess * OctreeHeight); - CellToSend* recvBuffer[nbProcess * OctreeHeight]; + char* recvBuffer[nbProcess * OctreeHeight]; memset(recvBuffer, 0, sizeof(CellClass*) * nbProcess * OctreeHeight); @@ -586,22 +578,23 @@ private: for(int idxProc = 0 ; idxProc < nbProcess ; ++idxProc){ const int toSendAtProcAtLevel = indexToSend[idxLevel * nbProcess + idxProc]; if(toSendAtProcAtLevel != 0){ - sendBuffer[idxLevel * nbProcess + idxProc] = new CellToSend[toSendAtProcAtLevel]; + sendBuffer[idxLevel * nbProcess + idxProc] = new char[toSendAtProcAtLevel * SizeOfCellToSend]; for(int idxLeaf = 0 ; idxLeaf < toSendAtProcAtLevel; ++idxLeaf){ - sendBuffer[idxLevel * nbProcess + idxProc][idxLeaf].index = toSend[idxLevel * nbProcess + idxProc][idxLeaf].getCurrentGlobalIndex(); - toSend[idxLevel * nbProcess + idxProc][idxLeaf].getCurrentCell()->serializeUp(sendBuffer[idxLevel * nbProcess + idxProc][idxLeaf].data); + const MortonIndex cellIndex = toSend[idxLevel * nbProcess + idxProc][idxLeaf].getCurrentGlobalIndex(); + memcpy(&sendBuffer[idxLevel * nbProcess + idxProc][idxLeaf * SizeOfCellToSend],&cellIndex, sizeof(MortonIndex)); + toSend[idxLevel * nbProcess + idxProc][idxLeaf].getCurrentCell()->serializeUp(&sendBuffer[idxLevel * nbProcess + idxProc][idxLeaf * SizeOfCellToSend] + sizeof(MortonIndex)); } - FMpi::MpiAssert( MPI_Isend( sendBuffer[idxLevel * nbProcess + idxProc], toSendAtProcAtLevel * int(sizeof(CellToSend)) , MPI_BYTE , + FMpi::MpiAssert( MPI_Isend( sendBuffer[idxLevel * nbProcess + idxProc], toSendAtProcAtLevel * SizeOfCellToSend , MPI_BYTE , idxProc, FMpi::TagLast + idxLevel, MPI_COMM_WORLD, &requests[iterRequest++]) , __LINE__ ); } const int toReceiveFromProcAtLevel = globalReceiveMap[(idxProc * nbProcess * OctreeHeight) + idxLevel * nbProcess + idProcess]; if(toReceiveFromProcAtLevel){ - recvBuffer[idxLevel * nbProcess + idxProc] = new CellToSend[toReceiveFromProcAtLevel]; + recvBuffer[idxLevel * nbProcess + idxProc] = new char[toReceiveFromProcAtLevel * SizeOfCellToSend]; - FMpi::MpiAssert( MPI_Irecv(recvBuffer[idxLevel * nbProcess + idxProc], toReceiveFromProcAtLevel * int(sizeof(CellToSend)), MPI_BYTE, + FMpi::MpiAssert( MPI_Irecv(recvBuffer[idxLevel * nbProcess + idxProc], toReceiveFromProcAtLevel * SizeOfCellToSend, MPI_BYTE, idxProc, FMpi::TagLast + idxLevel, MPI_COMM_WORLD, &requests[iterRequest++]) , __LINE__ ); } } @@ -686,9 +679,12 @@ private: FLightOctree tempTree; for(int idxProc = 0 ; idxProc < nbProcess ; ++idxProc){ const int toReceiveFromProcAtLevel = globalReceiveMap[(idxProc * nbProcess * OctreeHeight) + idxLevel * nbProcess + idProcess]; - const CellToSend* const cells = recvBuffer[idxLevel * nbProcess + idxProc]; + const char* const cells = recvBuffer[idxLevel * nbProcess + idxProc]; for(int idxCell = 0 ; idxCell < toReceiveFromProcAtLevel ; ++idxCell){ - tempTree.insertCell(cells[idxCell].index, cells[idxCell].data, idxLevel); + MortonIndex cellIndex = 0; + memcpy(&cellIndex, &cells[idxCell * SizeOfCellToSend], sizeof(MortonIndex)); + const char* const cellData = &cells[idxCell * SizeOfCellToSend] + sizeof(MortonIndex); + tempTree.insertCell(cellIndex, cellData, idxLevel); } } diff --git a/Src/Core/FFmmAlgorithmThreadProcPeriodic.hpp b/Src/Core/FFmmAlgorithmThreadProcPeriodic.hpp index 9aaec5aa59015d286c8c1189c67d3ff727b33693..31d980ebbd06a96c35626ca8e9df717891a4fe73 100644 --- a/Src/Core/FFmmAlgorithmThreadProcPeriodic.hpp +++ b/Src/Core/FFmmAlgorithmThreadProcPeriodic.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFmmAlgorithmThreadProcPeriodicPERIODIC_HPP #define FFmmAlgorithmThreadProcPeriodicPERIODIC_HPP diff --git a/Src/Core/FFmmAlgorithmThreadTsm.hpp b/Src/Core/FFmmAlgorithmThreadTsm.hpp index 4a189254bda6a34f80402542d384d080ab0653db..7adce618f4a0321aae396798723579eb13f143c3 100644 --- a/Src/Core/FFmmAlgorithmThreadTsm.hpp +++ b/Src/Core/FFmmAlgorithmThreadTsm.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMMALGORITHMTHREADTSM_HPP #define FFMMALGORITHMTHREADTSM_HPP diff --git a/Src/Core/FFmmAlgorithmTsm.hpp b/Src/Core/FFmmAlgorithmTsm.hpp index c210031e0981b58bb36018575d65b578c4db53ca..7ca3ed235d69614d8e856ff694761d007bb4769c 100644 --- a/Src/Core/FFmmAlgorithmTsm.hpp +++ b/Src/Core/FFmmAlgorithmTsm.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMMALGORITHMTSM_HPP #define FFMMALGORITHMTSM_HPP diff --git a/Src/Extensions/FExtendCellType.hpp b/Src/Extensions/FExtendCellType.hpp index 3db619be70b49bd45483e7c92b95c90d5fba1f3e..ff4fd7eb0ae7c404fbd8d99d0de893eaa91dd720 100644 --- a/Src/Extensions/FExtendCellType.hpp +++ b/Src/Extensions/FExtendCellType.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDCELLTYPE_HPP #define FEXTENDCELLTYPE_HPP diff --git a/Src/Extensions/FExtendCoordinate.hpp b/Src/Extensions/FExtendCoordinate.hpp index 212039f72a624c488c270d63ccfb108918d7f0e5..eba5d0e99ba85e731e4dfb09b70ba6bc561dbacc 100644 --- a/Src/Extensions/FExtendCoordinate.hpp +++ b/Src/Extensions/FExtendCoordinate.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDCOORDINATE_HPP #define FEXTENDCOORDINATE_HPP diff --git a/Src/Extensions/FExtendForces.hpp b/Src/Extensions/FExtendForces.hpp index 0195eb2ce5465ace4345b045b9880276e6874c12..324b9ee9e2e452c12ca441c73ed0b037ec02d7f7 100644 --- a/Src/Extensions/FExtendForces.hpp +++ b/Src/Extensions/FExtendForces.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDFORCES_HPP #define FEXTENDFORCES_HPP diff --git a/Src/Extensions/FExtendMortonIndex.hpp b/Src/Extensions/FExtendMortonIndex.hpp index 87da37325e89dd70e93a46402049e9c223734a49..90f9d6ce2de23c39e2872ad5ee655a75d9d63c30 100644 --- a/Src/Extensions/FExtendMortonIndex.hpp +++ b/Src/Extensions/FExtendMortonIndex.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDMORTONINDEX_HPP #define FEXTENDMORTONINDEX_HPP diff --git a/Src/Extensions/FExtendParticleType.hpp b/Src/Extensions/FExtendParticleType.hpp index 0d4cbc8ed53592e500ea90d9e740886fd87f7bcb..fdb5792e979688cbd54f1818813dab7ff30d7666 100644 --- a/Src/Extensions/FExtendParticleType.hpp +++ b/Src/Extensions/FExtendParticleType.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDPARTICLETYPE_HPP #define FEXTENDPARTICLETYPE_HPP diff --git a/Src/Extensions/FExtendPhysicalValue.hpp b/Src/Extensions/FExtendPhysicalValue.hpp index be73349c0a28803556809444086db94e2ff97fae..82a81626fccd7465dcf5de432d27dcad679c213d 100644 --- a/Src/Extensions/FExtendPhysicalValue.hpp +++ b/Src/Extensions/FExtendPhysicalValue.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FExtendPhysicalValue_HPP #define FExtendPhysicalValue_HPP diff --git a/Src/Extensions/FExtendPosition.hpp b/Src/Extensions/FExtendPosition.hpp index d8668c8d25118fba72517d5c1b2f60740f6c7326..ab4bcf807f082e71fe2d6a5346b7dcebc57bee6b 100644 --- a/Src/Extensions/FExtendPosition.hpp +++ b/Src/Extensions/FExtendPosition.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDPOSITION_HPP #define FEXTENDPOSITION_HPP diff --git a/Src/Extensions/FExtendPotential.hpp b/Src/Extensions/FExtendPotential.hpp index 4ee2e700a03534cddc14e1fac58742e840b25f93..e8c85f4b24f57b2229125a22bf5f04a352e3f328 100644 --- a/Src/Extensions/FExtendPotential.hpp +++ b/Src/Extensions/FExtendPotential.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDPOTENTIAL_HPP #define FEXTENDPOTENTIAL_HPP diff --git a/Src/Extensions/FExtendVelocity.hpp b/Src/Extensions/FExtendVelocity.hpp index 9f165a0fa5b4b54572878289fc6515398ca1056f..7e2f8e2acf69bfefc42d1f4730d0a79312842e97 100644 --- a/Src/Extensions/FExtendVelocity.hpp +++ b/Src/Extensions/FExtendVelocity.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDVELOCITY_HPP #define FEXTENDVELOCITY_HPP diff --git a/Src/Files/FAbstractLoader.hpp b/Src/Files/FAbstractLoader.hpp index f241f53d0f098d6388d060e88690b6b43c7cf4c2..6b86497897410bede5cac01486531f1d4a27963e 100644 --- a/Src/Files/FAbstractLoader.hpp +++ b/Src/Files/FAbstractLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FABSTRACTLOADER_HPP #define FABSTRACTLOADER_HPP diff --git a/Src/Files/FBasicLoader.hpp b/Src/Files/FBasicLoader.hpp index 979e3d85d9da7bf612a7242dfc5d10ebded67618..577d68e077c2f2a2bc9d852e396e73c1ba057509 100644 --- a/Src/Files/FBasicLoader.hpp +++ b/Src/Files/FBasicLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FBASICLOADER_HPP #define FBASICLOADER_HPP diff --git a/Src/Files/FEwalLoader.hpp b/Src/Files/FEwalLoader.hpp index e07a04b3491c665ddb342a3013287ca231d6bd42..cbc2ec5ee6754e344163aa7de5d0aa6c96cdf8a7 100644 --- a/Src/Files/FEwalLoader.hpp +++ b/Src/Files/FEwalLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMALOADER_HPP #define FFMALOADER_HPP diff --git a/Src/Files/FFmaBinLoader.hpp b/Src/Files/FFmaBinLoader.hpp index 5a8f5c47fae572da244fe0576b70755d157e930c..ffef46b088d674937a3934b9ab72c283b7f479dc 100644 --- a/Src/Files/FFmaBinLoader.hpp +++ b/Src/Files/FFmaBinLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMABINLOADER_HPP #define FFMABINLOADER_HPP diff --git a/Src/Files/FFmaLoader.hpp b/Src/Files/FFmaLoader.hpp index 34c94d7c3f0db21e8c26f833b43c7c9214019774..e75657d667fdc18b6fd14c533086ee568f598996 100644 --- a/Src/Files/FFmaLoader.hpp +++ b/Src/Files/FFmaLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMALOADER_HPP #define FFMALOADER_HPP diff --git a/Src/Files/FFmaScanfLoader.hpp b/Src/Files/FFmaScanfLoader.hpp index b5ddb4643b6f419c8699c64199d0c8f0f64ccb73..3106e2f16a0892e9abbf5d169cafbcffad75c0f5 100644 --- a/Src/Files/FFmaScanfLoader.hpp +++ b/Src/Files/FFmaScanfLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMASCANFLOADER_HPP #define FFMASCANFLOADER_HPP @@ -72,9 +67,8 @@ public: float x,y,z, fBoxWidth; const int nbReadElements = fscanf(file,"%d %f %f %f %f",&this->nbParticles,&fBoxWidth,&x,&y,&z); if(nbReadElements == 5){ - this->boxWidth = fBoxWidth; + this->boxWidth = fBoxWidth * 2; this->centerOfBox.setPosition(x,y,z); - this->boxWidth *= 2; } else{ fclose(file); diff --git a/Src/Files/FFmaTsmLoader.hpp b/Src/Files/FFmaTsmLoader.hpp index 3a78500ca66c25cba0370133cf097d8686b6d24a..8e1d892ae3f455d74b8beddcce76f0bbe01f8f3e 100644 --- a/Src/Files/FFmaTsmLoader.hpp +++ b/Src/Files/FFmaTsmLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMATSMLOADER_HPP #define FFMATSMLOADER_HPP diff --git a/Src/Files/FHLoader.hpp b/Src/Files/FHLoader.hpp index 00dac32bd25cf284ba4814806a360a8c2d1d3150..4cea7882c59571c1143be814703e4b219f829a57 100644 --- a/Src/Files/FHLoader.hpp +++ b/Src/Files/FHLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FHLOADER_HPP #define FHLOADER_HPP diff --git a/Src/Files/FMpiFmaLoader.hpp b/Src/Files/FMpiFmaLoader.hpp index 9f81706be9d88d98c7e5ff35ad394efc599fec39..cb28ce82d9ab2c530c929aae52b382f6ceff4dc3 100644 --- a/Src/Files/FMpiFmaLoader.hpp +++ b/Src/Files/FMpiFmaLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FMPIFMALOADER_HPP #define FMPIFMALOADER_HPP diff --git a/Src/Files/FMpiTreeBuilder.hpp b/Src/Files/FMpiTreeBuilder.hpp index d374b7aad6f3999fa4ae5add4f3c386e1fe84c30..8fad26df6ca220a114f3a8655be0870253927b71 100644 --- a/Src/Files/FMpiTreeBuilder.hpp +++ b/Src/Files/FMpiTreeBuilder.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FMPITREEBUILDER_H #define FMPITREEBUILDER_H diff --git a/Src/Files/FRandomLoader.hpp b/Src/Files/FRandomLoader.hpp index cc6a26b1843a1e6eb78a7cfe478a1c84035858fb..867c1080d7e62830fb3465b27434b30668c0f318 100644 --- a/Src/Files/FRandomLoader.hpp +++ b/Src/Files/FRandomLoader.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FHLOADER_HPP #define FHLOADER_HPP diff --git a/Src/Files/FTreeCsvSaver.hpp b/Src/Files/FTreeCsvSaver.hpp index bdd72a579e8854547d12090a5fdd2a7a97d581ae..e5ccca7a80c4a74c209a0ae3fceacb15cf086f98 100644 --- a/Src/Files/FTreeCsvSaver.hpp +++ b/Src/Files/FTreeCsvSaver.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTREECSVSAVER_HPP #define FTREECSVSAVER_HPP diff --git a/Src/Files/FTreeIO.hpp b/Src/Files/FTreeIO.hpp index a47e4387bb1e7075ae930e4ec930118feffac319..04a37392126b0c9f641523c03a89ce10b918e331 100644 --- a/Src/Files/FTreeIO.hpp +++ b/Src/Files/FTreeIO.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTREEIO_HPP #define FTREEIO_HPP diff --git a/Src/Fmb/FExtendFmbCell.hpp b/Src/Fmb/FExtendFmbCell.hpp index ba8b1b0a7097d6c8b7d33179e338797b57b85da8..e463a91a1d54743eb7e7aa428cab2fd683aa8c7b 100644 --- a/Src/Fmb/FExtendFmbCell.hpp +++ b/Src/Fmb/FExtendFmbCell.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FEXTENDFMBCELL_HPP #define FEXTENDFMBCELL_HPP diff --git a/Src/Fmb/FFmbComponents.hpp b/Src/Fmb/FFmbComponents.hpp index 4b8934d5c60f16100d6deb66db1a1d4fc566e364..865dcd9a9faf72e76cd50c393f6cd13b8877cc43 100644 --- a/Src/Fmb/FFmbComponents.hpp +++ b/Src/Fmb/FFmbComponents.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMBCOMPONENTS_HPP #define FFMBCOMPONENTS_HPP diff --git a/Src/Fmb/FFmbKernels.hpp b/Src/Fmb/FFmbKernels.hpp index e13135bb4e1bced1d130f7bbc8e68e1a715eac58..2ec13be010f35d7db49f1bd041d66b14fe2bf088 100644 --- a/Src/Fmb/FFmbKernels.hpp +++ b/Src/Fmb/FFmbKernels.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMBKERNELS_HPP #define FFMBKERNELS_HPP diff --git a/Src/Fmb/FFmbKernelsBlas.hpp b/Src/Fmb/FFmbKernelsBlas.hpp index fb7e31ed86773c89d7b02317f3ffb56c7dc03207..8a723176557f74be63d914b3c40507efa768d2f4 100644 --- a/Src/Fmb/FFmbKernelsBlas.hpp +++ b/Src/Fmb/FFmbKernelsBlas.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMBKERNELSBLAS_HPP #define FFMBKERNELSBLAS_HPP diff --git a/Src/Fmb/FFmbKernelsBlockBlas.hpp b/Src/Fmb/FFmbKernelsBlockBlas.hpp index d08fa04e57bfcbef8a8c06b5aed28c10e5624aff..14b15a970d561fb18d9c154d9f12915b67571400 100644 --- a/Src/Fmb/FFmbKernelsBlockBlas.hpp +++ b/Src/Fmb/FFmbKernelsBlockBlas.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FFMBKERNELSBLOCKBLAS_HPP #define FFMBKERNELSBLOCKBLAS_HPP diff --git a/Src/Kernels/FElecForcesKernels.hpp b/Src/Kernels/FAbstractSphericalKernel.hpp similarity index 67% rename from Src/Kernels/FElecForcesKernels.hpp rename to Src/Kernels/FAbstractSphericalKernel.hpp index 3cba301759612e612e63b1e34f08ffce4de05c02..3abc8133aa2645c4a4b7f7e847b65f7d8d7325da 100644 --- a/Src/Kernels/FElecForcesKernels.hpp +++ b/Src/Kernels/FAbstractSphericalKernel.hpp @@ -1,20 +1,15 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== -#ifndef FELECBASICKERNELS_HPP -#define FELECBASICKERNELS_HPP +#ifndef FABSTRACTSPHERICALKERNEL_HPP +#define FABSTRACTSPHERICALKERNEL_HPP #include "../Components/FAbstractKernels.hpp" @@ -28,50 +23,36 @@ /** * @author Berenger Bramas (berenger.bramas@inria.fr) -* @brief -* Please read the license -* +* This is the abstract spherical harmonic kernel */ template< class ParticleClass, class CellClass, class ContainerClass> -class FElecForcesKernels : public FAbstractKernels { - const int devP; //< The P - const int devM2lP; //< A secondary P - const FReal boxWidth; //< the box width at leaf level - const int treeHeight; //< The height of the tree +class FAbstractSphericalKernel : public FAbstractKernels { +protected: + const int devP; //< The P + const FReal boxWidth; //< the box width at leaf level + const int treeHeight; //< The height of the tree const int periodicLevels; //< The number of levels above 1 used for periodicity FHarmonic harmonic; //< The harmonic computation class // For normal computation - FComplexe* preL2LTransitions; //< The pre-computation for the L2L based on the level - FComplexe* preM2MTransitions; //< The pre-computation for the M2M based on the level + FComplexe** preL2LTransitions; //< The pre-computation for the L2L based on the level + FComplexe** preM2MTransitions; //< The pre-computation for the M2M based on the level - FComplexe* preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities - - // For harmonic computation - FComplexe* preL2LTransitionsPer; //< The pre-computation for the L2L based on the level - FComplexe* preM2MTransitionsPer; //< The pre-computation for the M2M based on the level - - FComplexe* preM2LTransitionsPer; //< The pre-computation for the M2L based on the level and the 189 possibilities - - /** To access te preL2L/preM2M right vector */ - int indexTransition(const int level, const int child){ - return level * 8 * harmonic.getExpSize() + child * harmonic.getExpSize(); - } - - /** To access te preM2L right vector */ - int indexM2LTransition(const int idxLevel,const int idxX,const int idxY,const int idxZ){ - return (idxLevel * 7 * 7 * 7 * devM2lP) + (((((idxX+3) * 7) + (idxY+3)) * 7 ) + (idxZ+3)) * devM2lP; - } /** Alloc and init pre-vectors*/ void allocAndInit(){ - preL2LTransitions = new FComplexe[treeHeight * 8 * harmonic.getExpSize()]; - preM2MTransitions = new FComplexe[treeHeight * 8 * harmonic.getExpSize()]; + preL2LTransitions = new FComplexe*[treeHeight + periodicLevels]; + memset(preL2LTransitions, 0, (treeHeight + periodicLevels) * sizeof(FComplexe*)); + preM2MTransitions = new FComplexe*[treeHeight + periodicLevels]; + memset(preM2MTransitions, 0, (treeHeight + periodicLevels) * sizeof(FComplexe*)); + + FReal treeWidthAtLevel = (boxWidth * FReal(1 << periodicLevels))/2; + for(int idxLevel = -periodicLevels ; idxLevel < treeHeight - 1 ; ++idxLevel ){ + preL2LTransitions[idxLevel + periodicLevels] = new FComplexe[ 8 * harmonic.getExpSize()]; + preM2MTransitions[idxLevel + periodicLevels] = new FComplexe[ 8 * harmonic.getExpSize()]; - FReal treeWidthAtLevel = boxWidth/2; - for(int idxLevel = 0 ; idxLevel < treeHeight - 1 ; ++idxLevel ){ const F3DPosition father(treeWidthAtLevel,treeWidthAtLevel,treeWidthAtLevel); treeWidthAtLevel /= 2; @@ -86,7 +67,7 @@ class FElecForcesKernels : public FAbstractKernels(&preM2MTransitions[indexTransition(idxLevel,idxChild)], harmonic.result(), harmonic.getExpSize()); + FMemUtils::copyall(&preM2MTransitions[idxLevel + periodicLevels][harmonic.getExpSize() * idxChild], harmonic.result(), harmonic.getExpSize()); const F3DPosition L2LVector ( (treeWidthAtLevel * FReal(1 + (childBox.getX() * 2))) - father.getX(), @@ -95,123 +76,42 @@ class FElecForcesKernels : public FAbstractKernels(&preL2LTransitions[indexTransition(idxLevel,idxChild)], harmonic.result(), harmonic.getExpSize()); + FMemUtils::copyall(&preL2LTransitions[idxLevel + periodicLevels][harmonic.getExpSize() * idxChild], harmonic.result(), harmonic.getExpSize()); } } - - // M2L transfer, there is a maximum of 3 neighbors in each direction, - // so 6 in each dimension - treeWidthAtLevel = boxWidth; - preM2LTransitions = new FComplexe[treeHeight * (7 * 7 * 7) * devM2lP]; - for(int idxLevel = 0 ; idxLevel < treeHeight ; ++idxLevel ){ - for(int idxX = -3 ; idxX <= 3 ; ++idxX ){ - for(int idxY = -3 ; idxY <= 3 ; ++idxY ){ - for(int idxZ = -3 ; idxZ <= 3 ; ++idxZ ){ - if(idxX || idxY || idxZ){ - const F3DPosition relativePos( FReal(idxX) * treeWidthAtLevel , FReal(idxY) * treeWidthAtLevel , FReal(idxZ) * treeWidthAtLevel ); - harmonic.computeOuter(FSpherical(relativePos)); - FMemUtils::copyall(&preM2LTransitions[indexM2LTransition(idxLevel,idxX,idxY,idxZ)], harmonic.result(), harmonic.getExpSize()); - } - } - } - } - treeWidthAtLevel /= 2; - } - } - - void allocAndInitPer(){ - if( periodicLevels ){ - preL2LTransitionsPer = new FComplexe[periodicLevels * 8 * harmonic.getExpSize()]; - preM2MTransitionsPer = new FComplexe[periodicLevels * 8 * harmonic.getExpSize()]; - - FReal treeWidthAtLevel = boxWidth; - for(int idxLevel = -1 ; idxLevel >= -periodicLevels ; --idxLevel ){ - const F3DPosition father(treeWidthAtLevel,treeWidthAtLevel,treeWidthAtLevel); - treeWidthAtLevel *= 2; - - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild ){ - FTreeCoordinate childBox; - childBox.setPositionFromMorton(idxChild,1); - - const F3DPosition M2MVector ( - father.getX() - (treeWidthAtLevel * FReal(1 + (childBox.getX() * 2))), - father.getY() - (treeWidthAtLevel * FReal(1 + (childBox.getY() * 2))), - father.getZ() - (treeWidthAtLevel * FReal(1 + (childBox.getZ() * 2))) - ); - - harmonic.computeInner(FSpherical(M2MVector)); - FMemUtils::copyall(&preM2MTransitionsPer[indexTransition(-1-idxLevel,idxChild)], harmonic.result(), harmonic.getExpSize()); - - const F3DPosition L2LVector ( - (treeWidthAtLevel * FReal(1 + (childBox.getX() * 2))) - father.getX(), - (treeWidthAtLevel * FReal(1 + (childBox.getY() * 2))) - father.getY(), - (treeWidthAtLevel * FReal(1 + (childBox.getZ() * 2))) - father.getZ() - ); - - harmonic.computeInner(FSpherical(L2LVector)); - FMemUtils::copyall(&preL2LTransitionsPer[indexTransition(-1-idxLevel,idxChild)], harmonic.result(), harmonic.getExpSize()); - } - } - - // M2L transfer, there is a maximum of 3 neighbors in each direction, - // so 6 in each dimension - treeWidthAtLevel = boxWidth*2; - preM2LTransitionsPer = new FComplexe[periodicLevels * (7 * 7 * 7) * devM2lP]; - for(int idxLevel = -1 ; idxLevel >= -periodicLevels ; --idxLevel ){ - for(int idxX = -3 ; idxX <= 3 ; ++idxX ){ - for(int idxY = -3 ; idxY <= 3 ; ++idxY ){ - for(int idxZ = -3 ; idxZ <= 3 ; ++idxZ ){ - if(idxX || idxY || idxZ){ - const F3DPosition relativePos( FReal(idxX) * treeWidthAtLevel , FReal(idxY) * treeWidthAtLevel , FReal(idxZ) * treeWidthAtLevel ); - harmonic.computeOuter(FSpherical(relativePos)); - FMemUtils::copyall(&preM2LTransitionsPer[indexM2LTransition(-1-idxLevel,idxX,idxY,idxZ)], harmonic.result(), harmonic.getExpSize()); - } - } - } - } - treeWidthAtLevel *= 2; - } - } } public: /** Kernel constructor */ - FElecForcesKernels(const int inDevP, const int inTreeHeight, const FReal inBoxWidth, const int inPeriodicLevel = 0) - : devP(inDevP), devM2lP(int(((inDevP*2)+1) * ((inDevP*2)+2) * 0.5)), boxWidth(inBoxWidth), + FAbstractSphericalKernel(const int inDevP, const int inTreeHeight, const FReal inBoxWidth, const int inPeriodicLevel = 0) + : devP(inDevP), boxWidth(inBoxWidth), treeHeight(inTreeHeight), periodicLevels(inPeriodicLevel), harmonic(inDevP), - preL2LTransitions(0), preM2MTransitions(0), preM2LTransitions(0), - preL2LTransitionsPer(0), preM2MTransitionsPer(0), preM2LTransitionsPer(0) { + preL2LTransitions(0), preM2MTransitions(0) { allocAndInit(); - allocAndInitPer(); } /** Copy constructor */ - FElecForcesKernels(const FElecForcesKernels& other) - : devP(other.devP), devM2lP(other.devM2lP), boxWidth(other.boxWidth), + FAbstractSphericalKernel(const FAbstractSphericalKernel& other) + : devP(other.devP), boxWidth(other.boxWidth), treeHeight(other.treeHeight), periodicLevels(other.periodicLevels), harmonic(other.devP), - preL2LTransitions(0), preM2MTransitions(0), preM2LTransitions(0), - preL2LTransitionsPer(0), preM2MTransitionsPer(0), preM2LTransitionsPer(0) { + preL2LTransitions(0), preM2MTransitions(0) { allocAndInit(); - allocAndInitPer(); } /** Default destructor */ - ~FElecForcesKernels(){ + virtual ~FAbstractSphericalKernel(){ + FMemUtils::DeleteAll(preL2LTransitions, treeHeight + periodicLevels); delete[] preL2LTransitions; + FMemUtils::DeleteAll(preM2MTransitions, treeHeight + periodicLevels); delete[] preM2MTransitions; - delete[] preM2LTransitions; - - delete[] preL2LTransitionsPer; - delete[] preM2MTransitionsPer; - delete[] preM2LTransitionsPer; } /** P2M with a cell and all its particles */ void P2M(CellClass* const inPole, const ContainerClass* const inParticles) { - FComplexe* const cellMultiPole = inPole->getMultipole(); + FComplexe* FRestrict const cellMultiPole = inPole->getMultipole(); // Copying the position is faster than using cell position const F3DPosition polePosition = inPole->getPosition(); // For all particles in the leaf box @@ -225,68 +125,27 @@ public: /** M2M with a cell and all its child */ void M2M(CellClass* const FRestrict inPole, const CellClass *const FRestrict *const FRestrict inChild, const int inLevel) { - FComplexe* const multipole_exp_target = inPole->getMultipole(); + FComplexe* FRestrict const multipole_exp_target = inPole->getMultipole(); // iter on each child and process M2M - if( inLevel >= 0){ - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ - if(inChild[idxChild]){ - multipoleToMultipole(multipole_exp_target, inChild[idxChild]->getMultipole(), &preM2MTransitions[indexTransition(inLevel,idxChild)]); - } - } - } - else{ - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ - if(inChild[idxChild]){ - multipoleToMultipole(multipole_exp_target, inChild[idxChild]->getMultipole(), &preM2MTransitionsPer[indexTransition(-1-inLevel,idxChild)]); - } + const FComplexe* FRestrict const preM2MTransitionsAtLevel = preM2MTransitions[inLevel + periodicLevels]; + for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ + if(inChild[idxChild]){ + multipoleToMultipole(multipole_exp_target, inChild[idxChild]->getMultipole(), &preM2MTransitionsAtLevel[idxChild * harmonic.getExpSize()]); } } } /** M2L with a cell and all the existing neighbors */ - void M2L(CellClass* const FRestrict pole, const CellClass* distantNeighbors[189], - const int size, const int inLevel) { - const FTreeCoordinate& coordCenter = pole->getCoordinate(); - // For all neighbors compute M2L - if( inLevel >= 0){ - for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ - const FTreeCoordinate& coordNeighbors = distantNeighbors[idxNeigh]->getCoordinate(); - const FComplexe* const transitionVector = &preM2LTransitions[indexM2LTransition(inLevel, - (coordCenter.getX() - coordNeighbors.getX()), - (coordCenter.getY() - coordNeighbors.getY()), - (coordCenter.getZ() - coordNeighbors.getZ()))]; - - multipoleToLocal(pole->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); - } - } - else { - for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ - const FTreeCoordinate& coordNeighbors = distantNeighbors[idxNeigh]->getCoordinate(); - const FComplexe* const transitionVector = &preM2LTransitionsPer[indexM2LTransition(-1-inLevel, - (coordCenter.getX() - coordNeighbors.getX()), - (coordCenter.getY() - coordNeighbors.getY()), - (coordCenter.getZ() - coordNeighbors.getZ()))]; - - multipoleToLocal(pole->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); - } - } - } + virtual void M2L(CellClass* const FRestrict pole, const CellClass* distantNeighbors[189], + const int size, const int inLevel) = 0; /** L2L with a cell and all its child */ void L2L(const CellClass* const FRestrict pole, CellClass* FRestrict *const FRestrict child, const int inLevel) { // iter on each child and process L2L - if( inLevel >= 0){ - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ - if(child[idxChild]){ - localToLocal(child[idxChild]->getLocal(), pole->getLocal(), &preL2LTransitions[indexTransition(inLevel,idxChild)]); - } - } - } - else{ - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ - if(child[idxChild]){ - localToLocal(child[idxChild]->getLocal(), pole->getLocal(), &preL2LTransitionsPer[indexTransition(-1-inLevel,idxChild)]); - } + const FComplexe* FRestrict const preL2LTransitionsAtLevel = preL2LTransitions[inLevel + periodicLevels]; + for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ + if(child[idxChild]){ + localToLocal(child[idxChild]->getLocal(), pole->getLocal(), &preL2LTransitionsAtLevel[idxChild * harmonic.getExpSize()]); } } } @@ -412,19 +271,9 @@ public: /////////////////////////////////////////////////////////////////////////////// /** Before Downward */ - void M2L(CellClass* const FRestrict local, const CellClass* distantNeighbors[189], + virtual void M2L(CellClass* const FRestrict local, const CellClass* distantNeighbors[189], const FTreeCoordinate neighborsRelativePositions[189], - const int size, const int inLevel) { - // For all neighbors compute M2L - for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ - const FComplexe* const transitionVector = &preM2LTransitions[indexM2LTransition(inLevel, - neighborsRelativePositions[idxNeigh].getX(), - neighborsRelativePositions[idxNeigh].getY(), - neighborsRelativePositions[idxNeigh].getZ())]; - - multipoleToLocal(local->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); - } - } + const int size, const int inLevel) = 0; /** After Downward */ @@ -514,7 +363,7 @@ private: * Phi(x) = sum_{n=0}^{+} sum_{m=-n}^{n} M_n^m O_n^{-m} (x - *p_center) * */ - void particleToMultiPole(FComplexe*const cellMultiPole, const F3DPosition& inPolePosition , + void particleToMultiPole(FComplexe* const cellMultiPole, const F3DPosition& inPolePosition , const ParticleClass& particle){ // Inner of Qi - Z0 => harmonic.result @@ -530,7 +379,6 @@ private: for(int k = 0 ; k <= j ; ++k, ++index_j_k){ harmonic.result(index_j_k).mulRealAndImag( qParticle * minus_one_pow_j ); cellMultiPole[index_j_k] += harmonic.result(index_j_k); - } // (-1)^J => -1 becomes 1 or 1 becomes -1 minus_one_pow_j = -minus_one_pow_j; @@ -641,107 +489,6 @@ private: } - /** M2L - *We compute the conversion of multipole_exp_src in *p_center_of_exp_src to - *a local expansion in *p_center_of_exp_target, and add the result to local_exp_target. - * - *O_n^l (with n=0..P, l=-n..n) being the former multipole expansion terms - *(whose center is *p_center_of_multipole_exp_src) we have for the new local - *expansion terms (whose center is *p_center_of_local_exp_target): - * - *L_j^k = sum{n=0..+} - *sum{l=-n..n} - *O_n^l Outer_{j+n}^{-k-l}(rho, alpha, beta) - * - *where (rho, alpha, beta) are the spherical coordinates of the vector : - *p_center_of_local_exp_src - *p_center_of_multipole_exp_target - * - *Remark: here we have always j+n >= |-k-l| - * - */ - void multipoleToLocal(FComplexe*const FRestrict local_exp, const FComplexe* const FRestrict multipole_exp_src, - const FComplexe* const FRestrict M2L_Outer_transfer){ - int index_j_k = 0; - - // L_j^k - // HPMSTART(51, "M2L computation (loops)"); - // j from 0 to P - for (int j = 0 ; j <= devP ; ++j){ - // (-1)^k - FReal pow_of_minus_1_for_k = 1.0; - //k from 0 to j - for (int k = 0 ; k <= j ; ++k, ++index_j_k){ - // (-1)^n - FReal pow_of_minus_1_for_n = 1.0; - - // work with a local variable - FComplexe L_j_k = local_exp[index_j_k]; - // n from 0 to P - for (int n = 0 ; n <= /*devP or*/ devP-j ; ++n){ - // O_n^l : here points on the source multipole expansion term of degree n and order |l| - const int index_n = harmonic.getPreExpRedirJ(n); - - // Outer_{j+n}^{-k-l} : here points on the M2L transfer function/expansion term of degree j+n and order |-k-l| - const int index_n_j = harmonic.getPreExpRedirJ(n+j); - - FReal pow_of_minus_1_for_l = pow_of_minus_1_for_n; // (-1)^l - - // We start with l=n (and not l=-n) so that we always set p_Outer_term to a correct value in the first loop. - int l = n; - for(/* l = n */ ; l > 0 ; --l){ // we have -k-l<0 and l>0 - const FComplexe M_n_l = multipole_exp_src[index_n + l]; - const FComplexe O_n_j__k_l = M2L_Outer_transfer[index_n_j + k + l]; - - L_j_k.incReal( pow_of_minus_1_for_l * pow_of_minus_1_for_k * - ((M_n_l.getReal() * O_n_j__k_l.getReal()) + - (M_n_l.getImag() * O_n_j__k_l.getImag()))); - L_j_k.incImag( pow_of_minus_1_for_l * pow_of_minus_1_for_k * - ((M_n_l.getImag() * O_n_j__k_l.getReal()) - - (M_n_l.getReal() * O_n_j__k_l.getImag()))); - - pow_of_minus_1_for_l = -pow_of_minus_1_for_l; - } - - for(/* l = 0 */; l >= -n && (-k-l) < 0 ; --l){ // we have -k-l<0 and l<=0 - const FComplexe M_n_l = multipole_exp_src[index_n - l]; - const FComplexe O_n_j__k_l = M2L_Outer_transfer[index_n_j + k + l]; - - L_j_k.incReal( pow_of_minus_1_for_k * - ((M_n_l.getReal() * O_n_j__k_l.getReal()) - - (M_n_l.getImag() * O_n_j__k_l.getImag()))); - L_j_k.decImag( pow_of_minus_1_for_k * - ((M_n_l.getImag() * O_n_j__k_l.getReal()) + - (M_n_l.getReal() * O_n_j__k_l.getImag()))); - - pow_of_minus_1_for_l = -pow_of_minus_1_for_l; - } - - for(/*l = -n-1 or l = -k-1 */; l >= -n ; --l){ // we have -k-l>=0 and l<=0 - const FComplexe M_n_l = multipole_exp_src[index_n - l]; - const FComplexe O_n_j__k_l = M2L_Outer_transfer[index_n_j - (k + l)]; - - L_j_k.incReal( pow_of_minus_1_for_l * - ((M_n_l.getReal() * O_n_j__k_l.getReal()) + - (M_n_l.getImag() * O_n_j__k_l.getImag()))); - L_j_k.incImag( pow_of_minus_1_for_l * - ((M_n_l.getReal() * O_n_j__k_l.getImag()) - - (M_n_l.getImag() * O_n_j__k_l.getReal()))); - - pow_of_minus_1_for_l = -pow_of_minus_1_for_l; - } - - pow_of_minus_1_for_n = -pow_of_minus_1_for_n; - }//n - - // put in the local vector - local_exp[index_j_k] = L_j_k; - - pow_of_minus_1_for_k = -pow_of_minus_1_for_k; - }//k - } - } - - /** L2L *We compute the shift of local_exp_src from *p_center_of_exp_src to *p_center_of_exp_target, and set the result to local_exp_target. @@ -1080,6 +827,6 @@ public: }; -#endif //FELECBASICKERNELS_HPP +#endif //FABSTRACTSPHERICALKERNEL_HPP diff --git a/Src/Kernels/FComputeCell.hpp b/Src/Kernels/FComputeCell.hpp deleted file mode 100644 index f8ce0f1f002ed59d04621238c9bf5f55e857107a..0000000000000000000000000000000000000000 --- a/Src/Kernels/FComputeCell.hpp +++ /dev/null @@ -1,109 +0,0 @@ -// =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL -// =================================================================================== -#ifndef FCOMPUTECELL_HPP -#define FCOMPUTECELL_HPP - - - -#include "../Utils/FComplexe.hpp" -#include "../Utils/FMemUtils.hpp" - -#include "../Components/FBasicCell.hpp" - -/** -* @author Berenger Bramas (berenger.bramas@inria.fr) -* @class FComputeCell -* Please read the license. -* -*/ -class FComputeCell : public FBasicCell { -protected: - static int DevP; - static int ExpP; - - FComplexe* multipole_exp; //< For multipole extenssion - FComplexe* local_exp; //< For local extenssion - -public: - static void Init(const int inDevP){ - DevP = inDevP; - ExpP = int((DevP+1) * (DevP+2) * 0.5); - } - - static int GetP(){ - return DevP; - } - - static int GetExp(){ - return ExpP; - } - - - /** Default constructor */ - FComputeCell() - : multipole_exp(0), local_exp(0){ - multipole_exp = new FComplexe[ExpP]; - local_exp = new FComplexe[ExpP]; - } - - /** Constructor */ - FComputeCell(const FComputeCell& other) - : multipole_exp(0), local_exp(0){ - multipole_exp = new FComplexe[ExpP]; - local_exp = new FComplexe[ExpP]; - (*this) = other; - } - - /** Default destructor */ - virtual ~FComputeCell(){ - delete[] multipole_exp; - delete[] local_exp; - } - - /** Copy constructor */ - FComputeCell& operator=(const FComputeCell& other) { - FMemUtils::copyall(multipole_exp, other.multipole_exp, ExpP); - FMemUtils::copyall(local_exp, other.local_exp, ExpP); - return *this; - } - - /** Get Multipole */ - const FComplexe* getMultipole() const { - return multipole_exp; - } - /** Get Local */ - const FComplexe* getLocal() const { - return local_exp; - } - - /** Get Multipole */ - FComplexe* getMultipole() { - return multipole_exp; - } - /** Get Local */ - FComplexe* getLocal() { - return local_exp; - } -}; - - -int FComputeCell::DevP(-1); -int FComputeCell::ExpP(-1); - - -#endif //FCOMPUTECELL_HPP - - diff --git a/Src/Kernels/FHarmonic.hpp b/Src/Kernels/FHarmonic.hpp index 1d80a889d688b73f75691481c80cc3b8213b243d..a4ae5f0942b97abbd5e187a3e20d76fe7d26104c 100644 --- a/Src/Kernels/FHarmonic.hpp +++ b/Src/Kernels/FHarmonic.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FHARMONIC_HPP #define FHARMONIC_HPP @@ -28,6 +23,7 @@ class FHarmonic : public FNoAssignement { const int devP; //< P const int expSize; //< Exponen Size + const int nExpSize; //< FComplexe* harmonic;//< Harmonic Result FComplexe* cosSin; //< Cos/Sin precomputed values @@ -135,6 +131,7 @@ public: explicit FHarmonic(const int inDevP) : devP(inDevP),expSize(int(((inDevP)+1) * ((inDevP)+2) * 0.5)), + nExpSize((inDevP + 1) * (inDevP + 1)), harmonic(0), cosSin(0), legendre(0), thetaDerivatedResult(0), sphereHarmoInnerCoef(0), sphereHarmoOuterCoef(0), preExpRedirJ(0) { @@ -142,7 +139,7 @@ public: } FHarmonic(const FHarmonic& other) - : devP(other.devP),expSize(int(((other.devP)+1) * ((other.devP)+2) * 0.5)), + : devP(other.devP),expSize(other.expSize), nExpSize(other.expSize), harmonic(0), cosSin(0), legendre(0), thetaDerivatedResult(0), sphereHarmoInnerCoef(0), sphereHarmoOuterCoef(0), preExpRedirJ(0) { @@ -163,6 +160,10 @@ public: return expSize; } + int getNExpSize() const{ + return nExpSize; + } + FComplexe* result(){ return harmonic; } diff --git a/Src/Kernels/FSphericalBlasKernel.hpp b/Src/Kernels/FSphericalBlasKernel.hpp new file mode 100644 index 0000000000000000000000000000000000000000..8a3c3d4a131807d5d584be1c107a2cb9c80e0f5c --- /dev/null +++ b/Src/Kernels/FSphericalBlasKernel.hpp @@ -0,0 +1,214 @@ +// =================================================================================== +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. +// =================================================================================== +#ifndef FSPHERICALBLASKERNEL_HPP +#define FSPHERICALBLASKERNEL_HPP + +#include "FAbstractSphericalKernel.hpp" + +#include "../Utils/FMemUtils.hpp" +#include "../Utils/FBlas.hpp" + +/** +* @author Berenger Bramas (berenger.bramas@inria.fr) +* This class is a spherical harmonic kernels using blas +*/ +template< class ParticleClass, class CellClass, class ContainerClass> +class FSphericalBlasKernel : public FAbstractSphericalKernel { +protected: + typedef FAbstractSphericalKernel Parent; + + const int FF_MATRIX_ROW_DIM; //< The blas matrix number of rows + const int FF_MATRIX_COLUMN_DIM; //< The blas matrix number of columns + const int FF_MATRIX_SIZE; //< The blas matrix size + + FComplexe* temporaryMultiSource; //< To perform the M2L without allocating at each call + FComplexe** preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities + + /** To access te precomputed M2L transfer matrixes */ + int indexM2LTransition(const int idxX,const int idxY,const int idxZ) const { + return (((((idxX+3) * 7) + (idxY+3)) * 7 ) + (idxZ+3)) * FF_MATRIX_SIZE; + } + + /** Alloc and init pre-vectors*/ + void allocAndInit(){ + temporaryMultiSource = new FComplexe[FF_MATRIX_COLUMN_DIM]; + + FHarmonic blasHarmonic(Parent::devP * 2); + + // M2L transfer, there is a maximum of 3 neighbors in each direction, + // so 6 in each dimension + FReal treeWidthAtLevel = Parent::boxWidth * FReal( 1 << Parent::periodicLevels); + preM2LTransitions = new FComplexe*[Parent::treeHeight + Parent::periodicLevels]; + memset(preM2LTransitions, 0, sizeof(FComplexe*) * (Parent::treeHeight + Parent::periodicLevels)); + + for(int idxLevel = -Parent::periodicLevels ; idxLevel < Parent::treeHeight ; ++idxLevel ){ + preM2LTransitions[idxLevel + Parent::periodicLevels] = new FComplexe[(7 * 7 * 7) * FF_MATRIX_SIZE]; + + for(int idxX = -3 ; idxX <= 3 ; ++idxX ){ + for(int idxY = -3 ; idxY <= 3 ; ++idxY ){ + for(int idxZ = -3 ; idxZ <= 3 ; ++idxZ ){ + if(FMath::Abs(idxX) > 1 || FMath::Abs(idxY) > 1 || FMath::Abs(idxZ) > 1){ + const F3DPosition relativePos( FReal(idxX) * treeWidthAtLevel , FReal(idxY) * treeWidthAtLevel , FReal(idxZ) * treeWidthAtLevel ); + blasHarmonic.computeOuter(FSpherical(relativePos)); + + FComplexe* FRestrict fillTransfer = &preM2LTransitions[idxLevel + Parent::periodicLevels][indexM2LTransition(idxX,idxY,idxZ)]; + + for(int M = 0 ; M <= Parent::devP ; ++M){ + for (int m = 0 ; m <= M ; ++m){ + for (int N = 0 ; N <= Parent::devP ; ++N){ + for (int n = 0 ; n <= 2*N ; ++n, ++fillTransfer){ + const int k = N-n-m; + if (k < 0){ + const FReal pow_of_minus_1 = FReal((k&1) ? -1 : 1); + fillTransfer->setReal( pow_of_minus_1 * blasHarmonic.result()[blasHarmonic.getPreExpRedirJ(M+N)-k].getReal()); + fillTransfer->setImag((-pow_of_minus_1) * blasHarmonic.result()[blasHarmonic.getPreExpRedirJ(M+N)-k].getImag()); + } + else{ + (*fillTransfer) = blasHarmonic.result()[blasHarmonic.getPreExpRedirJ(M+N)+k]; + } + + } + } + } + } + } + } + } + } + treeWidthAtLevel /= 2; + } + } + + +public: + /** Constructor + * @param inDevP the polynomial degree + * @param inThreeHeight the height of the tree + * @param inBoxWidth the size of the simulation box + * @param inPeriodicLevel the number of level upper to 0 that will be requiried + */ + FSphericalBlasKernel(const int inDevP, const int inTreeHeight, const FReal inBoxWidth, const int inPeriodicLevel = 0) + : Parent(inDevP, inTreeHeight, inBoxWidth, inPeriodicLevel), + FF_MATRIX_ROW_DIM(Parent::harmonic.getExpSize()), FF_MATRIX_COLUMN_DIM(Parent::harmonic.getNExpSize()), + FF_MATRIX_SIZE(FF_MATRIX_ROW_DIM * FF_MATRIX_COLUMN_DIM), + temporaryMultiSource(0), preM2LTransitions(0){ + allocAndInit(); + } + + /** Copy constructor */ + FSphericalBlasKernel(const FSphericalBlasKernel& other) + : Parent(other), + FF_MATRIX_ROW_DIM(other.FF_MATRIX_ROW_DIM), FF_MATRIX_COLUMN_DIM(other.FF_MATRIX_COLUMN_DIM), + FF_MATRIX_SIZE(other.FF_MATRIX_SIZE), + temporaryMultiSource(0), preM2LTransitions(0) { + allocAndInit(); + } + + /** Destructor */ + ~FSphericalBlasKernel(){ + delete[] temporaryMultiSource; + FMemUtils::DeleteAll(preM2LTransitions, Parent::treeHeight + Parent::periodicLevels); + delete[] preM2LTransitions; + } + + /** M2L with a cell and all the existing neighbors */ + void M2L(CellClass* const FRestrict pole, const CellClass* distantNeighbors[189], + const int size, const int inLevel) { + const FTreeCoordinate& coordCenter = pole->getCoordinate(); + // For all neighbors compute M2L + for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ + const FTreeCoordinate& coordNeighbors = distantNeighbors[idxNeigh]->getCoordinate(); + const FComplexe* const transitionVector = &preM2LTransitions[inLevel + Parent::periodicLevels] + [indexM2LTransition((coordCenter.getX() - coordNeighbors.getX()), + (coordCenter.getY() - coordNeighbors.getY()), + (coordCenter.getZ() - coordNeighbors.getZ()))]; + + multipoleToLocal(pole->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); + } + } + + /** Before Downward */ + void M2L(CellClass* const FRestrict local, const CellClass* distantNeighbors[189], + const FTreeCoordinate neighborsRelativePositions[189], + const int size, const int inLevel) { + // For all neighbors compute M2L + for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ + const FComplexe* const transitionVector = &preM2LTransitions[inLevel + Parent::periodicLevels] + [indexM2LTransition(neighborsRelativePositions[idxNeigh].getX(), + neighborsRelativePositions[idxNeigh].getY(), + neighborsRelativePositions[idxNeigh].getZ())]; + + multipoleToLocal(local->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); + } + } + + + /** preExpNExp + * @param exp an exponent vector to create an computable vector + */ + void preExpNExp(FComplexe* const exp) const { + for(int j = Parent::devP; j>= 0 ; --j){ + // Position in 'exp': (j*(j+1)*0.5) + k + // Position in 'nexp': j*(j+1) + k + const int j_j1 = j*(j+1); + const int j_j1_div_2 = int(j_j1 * 0.5); + + // Positive (or null) orders: + for(int k = j ; k >= 0; --k){ + exp[j_j1 + k] = exp[j_j1_div_2 + k]; + } + + // Negative orders: + FReal minus_1_pow_k = FReal( j&1 ? -1 : 1); + for(int k = -j ; k < 0 ; ++k ){ + exp[j_j1 + k].setReal(minus_1_pow_k * exp[j_j1 + (-k)].getReal()); + exp[j_j1 + k].setImag((-minus_1_pow_k) * exp[j_j1 + (-k)].getImag()); + minus_1_pow_k = -minus_1_pow_k; + } + } + } + + /** M2L + *We compute the conversion of multipole_exp_src in *p_center_of_exp_src to + *a local expansion in *p_center_of_exp_target, and add the result to local_exp_target. + * + *O_n^l (with n=0..P, l=-n..n) being the former multipole expansion terms + *(whose center is *p_center_of_multipole_exp_src) we have for the new local + *expansion terms (whose center is *p_center_of_local_exp_target): + * + *L_j^k = sum{n=0..+} + *sum{l=-n..n} + *O_n^l Outer_{j+n}^{-k-l}(rho, alpha, beta) + * + *where (rho, alpha, beta) are the spherical coordinates of the vector : + *p_center_of_local_exp_src - *p_center_of_multipole_exp_target + * + *Remark: here we have always j+n >= |-k-l| + * + */ + void multipoleToLocal(FComplexe*const FRestrict local_exp, const FComplexe* const FRestrict multipole_exp_src, + const FComplexe* const FRestrict M2L_Outer_transfer){ + // Copy original vector and compute exp2nexp + FMemUtils::copyall(temporaryMultiSource, multipole_exp_src, CellClass::GetPoleSize()); + // Get a computable vector + preExpNExp(temporaryMultiSource); + + FReal alpha_and_beta[2] = {1.0, 0.0}; + + cblas_gemv(CblasColMajor, CblasTrans, + FF_MATRIX_COLUMN_DIM, FF_MATRIX_ROW_DIM, + alpha_and_beta, M2L_Outer_transfer, + FF_MATRIX_COLUMN_DIM, temporaryMultiSource, 1, + alpha_and_beta, local_exp, 1); + } +}; + +#endif // FSPHERICALBLASKERNEL_HPP diff --git a/Src/Kernels/FSphericalCell.hpp b/Src/Kernels/FSphericalCell.hpp index 4d27d82ebebcd493453a04080cdc986eee3ba127..f175b67af963bbc177b98a08bb48ed2374d08cb7 100644 --- a/Src/Kernels/FSphericalCell.hpp +++ b/Src/Kernels/FSphericalCell.hpp @@ -1,68 +1,71 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FSPHERICALCELL_HPP #define FSPHERICALCELL_HPP +#include "../Utils/FAbstractSendable.hpp" #include "../Utils/FComplexe.hpp" #include "../Utils/FMemUtils.hpp" - +#include "../Extensions/FExtendCellType.hpp" #include "../Components/FBasicCell.hpp" /** * @author Berenger Bramas (berenger.bramas@inria.fr) -* @class FSphericalCell -* Please read the license. -* */ class FSphericalCell : public FBasicCell { protected: static int DevP; - static int ExpP; + static int LocalSize; + static int PoleSize; + static bool UseBlas; FComplexe* multipole_exp; //< For multipole extenssion FComplexe* local_exp; //< For local extenssion public: - static void Init(const int inDevP){ - DevP = inDevP; - ExpP = int((DevP+1) * (DevP+2) * 0.5); + static void Init(const int inDevP, const bool inUseBlas = false){ + DevP = inDevP; + const int ExpP = int((inDevP+1) * (inDevP+2) * 0.5); + const int NExpP = (inDevP+1) * (inDevP+1); + + LocalSize = ExpP; + if(inUseBlas) { + PoleSize = NExpP; + } + else{ + PoleSize = ExpP; + } } - static int GetP(){ - return DevP; + static int GetLocalSize(){ + return LocalSize; } - static int GetExp(){ - return ExpP; + static int GetPoleSize(){ + return PoleSize; } - /** Default constructor */ FSphericalCell() : multipole_exp(0), local_exp(0){ - multipole_exp = new FComplexe[ExpP]; - local_exp = new FComplexe[ExpP]; + multipole_exp = new FComplexe[PoleSize]; + local_exp = new FComplexe[LocalSize]; } /** Constructor */ FSphericalCell(const FSphericalCell& other) : multipole_exp(0), local_exp(0){ - multipole_exp = new FComplexe[ExpP]; - local_exp = new FComplexe[ExpP]; + multipole_exp = new FComplexe[PoleSize]; + local_exp = new FComplexe[LocalSize]; (*this) = other; } @@ -74,8 +77,8 @@ public: /** Copy constructor */ FSphericalCell& operator=(const FSphericalCell& other) { - FMemUtils::copyall(multipole_exp, other.multipole_exp, ExpP); - FMemUtils::copyall(local_exp, other.local_exp, ExpP); + FMemUtils::copyall(multipole_exp, other.multipole_exp, PoleSize); + FMemUtils::copyall(local_exp, other.local_exp, LocalSize); return *this; } @@ -98,10 +101,57 @@ public: } }; - int FSphericalCell::DevP(-1); -int FSphericalCell::ExpP(-1); +int FSphericalCell::LocalSize(-1); +int FSphericalCell::PoleSize(-1); + + +/** +* @author Berenger Bramas (berenger.bramas@inria.fr) +*/ +class FTypedSphericalCell : public FSphericalCell, public FExtendCellType { +public: +}; + + +/** +* @author Berenger Bramas (berenger.bramas@inria.fr) +*/ +class FSendableSphericalCell : public FSphericalCell , public FAbstractSendable { +public: + static int SerializedSizeDown; + static int SerializedSizeUp; + + static void Init(const int inDevP){ + FSphericalCell::Init(inDevP); + SerializedSizeDown = PoleSize * sizeof(FComplexe) + sizeof(FBasicCell); + SerializedSizeUp = LocalSize * sizeof(FComplexe) + sizeof(FBasicCell); + } + + /////////////////////////////////////////////////////// + // to extend FAbstractSendable + /////////////////////////////////////////////////////// + void serializeUp(void* const buffer) const { + memcpy(buffer, (FBasicCell*)this, sizeof(FBasicCell)); + memcpy((char*)(buffer) + sizeof(FBasicCell), multipole_exp, sizeof(FComplexe)*PoleSize ); + } + void deserializeUp(const void* const buffer){ + memcpy((FBasicCell*)this, buffer, sizeof(FBasicCell)); + memcpy(multipole_exp, (char*)(buffer) + sizeof(FBasicCell), sizeof(FComplexe)*PoleSize ); + } + + void serializeDown(void* const buffer) const { + memcpy(buffer, (FBasicCell*)this, sizeof(FBasicCell)); + memcpy((char*)(buffer) + sizeof(FBasicCell), local_exp, sizeof(FComplexe)*LocalSize ); + } + void deserializeDown(const void* const buffer){ + memcpy((FBasicCell*)this, buffer, sizeof(FBasicCell)); + memcpy(local_exp, (char*)(buffer) + sizeof(FBasicCell), sizeof(FComplexe)*LocalSize ); + } +}; +int FSendableSphericalCell::SerializedSizeDown(-1); +int FSendableSphericalCell::SerializedSizeUp(-1); #endif //FSPHERICALCELL_HPP diff --git a/Src/Kernels/FSphericalKernel.hpp b/Src/Kernels/FSphericalKernel.hpp index cb7c37a68e6d0dad96b9fe92b127b241b8d8822d..7403f4c156f2524d279a3daf0ecff7e2bd4baf03 100644 --- a/Src/Kernels/FSphericalKernel.hpp +++ b/Src/Kernels/FSphericalKernel.hpp @@ -1,246 +1,89 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FSPHERICALKERNEL_HPP #define FSPHERICALKERNEL_HPP -#include "../Components/FAbstractKernels.hpp" - -#include "../Utils/FGlobal.hpp" -#include "../Utils/FTrace.hpp" +#include "FAbstractSphericalKernel.hpp" #include "../Utils/FMemUtils.hpp" -#include "../Containers/FTreeCoordinate.hpp" - -#include "FHarmonic.hpp" - /** * @author Berenger Bramas (berenger.bramas@inria.fr) -* @brief -* Please read the license -* +* This class is the basic spherical harmonic kernel */ template< class ParticleClass, class CellClass, class ContainerClass> -class FSphericalKernel : public FAbstractKernels { - const int devP; //< The P - const int devM2lP; //< A secondary P - const FReal boxWidth; //< the box width at leaf level - const int treeHeight; //< The height of the tree - - const int periodicLevels; //< The number of levels above 1 used for periodicity - - FHarmonic harmonic; //< The harmonic computation class +class FSphericalKernel : public FAbstractSphericalKernel { +protected: + typedef FAbstractSphericalKernel Parent; - // For normal computation - FComplexe* preL2LTransitions; //< The pre-computation for the L2L based on the level - FComplexe* preM2MTransitions; //< The pre-computation for the M2M based on the level + const int devM2lP; //< A secondary P - FComplexe* preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities - - // For harmonic computation - FComplexe* preL2LTransitionsPer; //< The pre-computation for the L2L based on the level - FComplexe* preM2MTransitionsPer; //< The pre-computation for the M2M based on the level - - FComplexe* preM2LTransitionsPer; //< The pre-computation for the M2L based on the level and the 189 possibilities - - /** To access te preL2L/preM2M right vector */ - int indexTransition(const int level, const int child){ - return level * 8 * harmonic.getExpSize() + child * harmonic.getExpSize(); - } + FComplexe** preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities - /** To access te preM2L right vector */ - int indexM2LTransition(const int idxLevel,const int idxX,const int idxY,const int idxZ){ - return (idxLevel * 7 * 7 * 7 * devM2lP) + (((((idxX+3) * 7) + (idxY+3)) * 7 ) + (idxZ+3)) * devM2lP; + /** To access te pre computed M2L transfer vector */ + int indexM2LTransition(const int idxX,const int idxY,const int idxZ) const { + return (((((idxX+3) * 7) + (idxY+3)) * 7 ) + (idxZ+3)) * devM2lP; } /** Alloc and init pre-vectors*/ void allocAndInit(){ - preL2LTransitions = new FComplexe[treeHeight * 8 * harmonic.getExpSize()]; - preM2MTransitions = new FComplexe[treeHeight * 8 * harmonic.getExpSize()]; - - FReal treeWidthAtLevel = boxWidth/2; - for(int idxLevel = 0 ; idxLevel < treeHeight - 1 ; ++idxLevel ){ - const F3DPosition father(treeWidthAtLevel,treeWidthAtLevel,treeWidthAtLevel); - treeWidthAtLevel /= 2; - - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild ){ - FTreeCoordinate childBox; - childBox.setPositionFromMorton(idxChild,1); - - const F3DPosition M2MVector ( - father.getX() - (treeWidthAtLevel * FReal(1 + (childBox.getX() * 2))), - father.getY() - (treeWidthAtLevel * FReal(1 + (childBox.getY() * 2))), - father.getZ() - (treeWidthAtLevel * FReal(1 + (childBox.getZ() * 2))) - ); - - harmonic.computeInner(FSpherical(M2MVector)); - FMemUtils::copyall(&preM2MTransitions[indexTransition(idxLevel,idxChild)], harmonic.result(), harmonic.getExpSize()); - - const F3DPosition L2LVector ( - (treeWidthAtLevel * FReal(1 + (childBox.getX() * 2))) - father.getX(), - (treeWidthAtLevel * FReal(1 + (childBox.getY() * 2))) - father.getY(), - (treeWidthAtLevel * FReal(1 + (childBox.getZ() * 2))) - father.getZ() - ); - - harmonic.computeInner(FSpherical(L2LVector)); - FMemUtils::copyall(&preL2LTransitions[indexTransition(idxLevel,idxChild)], harmonic.result(), harmonic.getExpSize()); - } - } - // M2L transfer, there is a maximum of 3 neighbors in each direction, // so 6 in each dimension - treeWidthAtLevel = boxWidth; - preM2LTransitions = new FComplexe[treeHeight * (7 * 7 * 7) * devM2lP]; - for(int idxLevel = 0 ; idxLevel < treeHeight ; ++idxLevel ){ + preM2LTransitions = new FComplexe*[Parent::treeHeight + Parent::periodicLevels]; + memset(preM2LTransitions, 0, sizeof(FComplexe*) * (Parent::treeHeight + Parent::periodicLevels)); + // We start from the higher level + FReal treeWidthAtLevel = Parent::boxWidth * FReal(1 << Parent::periodicLevels); + for(int idxLevel = -Parent::periodicLevels ; idxLevel < Parent::treeHeight ; ++idxLevel ){ + // Allocate data for this level + preM2LTransitions[idxLevel + Parent::periodicLevels] = new FComplexe[(7 * 7 * 7) * devM2lP]; + // Precompute transfer vector for(int idxX = -3 ; idxX <= 3 ; ++idxX ){ for(int idxY = -3 ; idxY <= 3 ; ++idxY ){ for(int idxZ = -3 ; idxZ <= 3 ; ++idxZ ){ if(FMath::Abs(idxX) > 1 || FMath::Abs(idxY) > 1 || FMath::Abs(idxZ) > 1){ const F3DPosition relativePos( FReal(idxX) * treeWidthAtLevel , FReal(idxY) * treeWidthAtLevel , FReal(idxZ) * treeWidthAtLevel ); - harmonic.computeOuter(FSpherical(relativePos)); - FMemUtils::copyall(&preM2LTransitions[indexM2LTransition(idxLevel,idxX,idxY,idxZ)], harmonic.result(), harmonic.getExpSize()); + Parent::harmonic.computeOuter(FSpherical(relativePos)); + FMemUtils::copyall(&preM2LTransitions[idxLevel + Parent::periodicLevels][indexM2LTransition(idxX,idxY,idxZ)], Parent::harmonic.result(), Parent::harmonic.getExpSize()); } } } } + // We divide the bow per 2 when we go down treeWidthAtLevel /= 2; } } - void allocAndInitPer(){ - if( periodicLevels ){ - preL2LTransitionsPer = new FComplexe[periodicLevels * 8 * harmonic.getExpSize()]; - preM2MTransitionsPer = new FComplexe[periodicLevels * 8 * harmonic.getExpSize()]; - - FReal treeWidthAtLevel = boxWidth; - for(int idxLevel = 1 ; idxLevel <= periodicLevels ; ++idxLevel ){ - const F3DPosition father(treeWidthAtLevel,treeWidthAtLevel,treeWidthAtLevel); - treeWidthAtLevel *= 2; - - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild ){ - FTreeCoordinate childBox; - childBox.setPositionFromMorton(idxChild,1); - - const F3DPosition M2MVector ( - father.getX() - (treeWidthAtLevel * FReal(1 + (childBox.getX() * 2))), - father.getY() - (treeWidthAtLevel * FReal(1 + (childBox.getY() * 2))), - father.getZ() - (treeWidthAtLevel * FReal(1 + (childBox.getZ() * 2))) - ); - - harmonic.computeInner(FSpherical(M2MVector)); - FMemUtils::copyall(&preM2MTransitionsPer[indexTransition(idxLevel-1,idxChild)], harmonic.result(), harmonic.getExpSize()); - - const F3DPosition L2LVector ( - (treeWidthAtLevel * FReal(1 + (childBox.getX() * 2))) - father.getX(), - (treeWidthAtLevel * FReal(1 + (childBox.getY() * 2))) - father.getY(), - (treeWidthAtLevel * FReal(1 + (childBox.getZ() * 2))) - father.getZ() - ); - - harmonic.computeInner(FSpherical(L2LVector)); - FMemUtils::copyall(&preL2LTransitionsPer[indexTransition(idxLevel-1,idxChild)], harmonic.result(), harmonic.getExpSize()); - } - } - - // M2L transfer, there is a maximum of 3 neighbors in each direction, - // so 6 in each dimension - treeWidthAtLevel = boxWidth*2; - preM2LTransitionsPer = new FComplexe[periodicLevels * (7 * 7 * 7) * devM2lP]; - for(int idxLevel = 1 ; idxLevel <= periodicLevels ; ++idxLevel ){ - for(int idxX = -3 ; idxX <= 3 ; ++idxX ){ - for(int idxY = -3 ; idxY <= 3 ; ++idxY ){ - for(int idxZ = -3 ; idxZ <= 3 ; ++idxZ ){ - if(FMath::Abs(idxX) > 1 || FMath::Abs(idxY) > 1 || FMath::Abs(idxZ) > 1){ - const F3DPosition relativePos( FReal(idxX) * treeWidthAtLevel , FReal(idxY) * treeWidthAtLevel , FReal(idxZ) * treeWidthAtLevel ); - harmonic.computeOuter(FSpherical(relativePos)); - FMemUtils::copyall(&preM2LTransitionsPer[indexM2LTransition(idxLevel-1,idxX,idxY,idxZ)], harmonic.result(), harmonic.getExpSize()); - } - } - } - } - treeWidthAtLevel *= 2; - } - } - } - public: - /** Kernel constructor */ + /** Constructor + * @param inDevP the polynomial degree + * @param inThreeHeight the height of the tree + * @param inBoxWidth the size of the simulation box + * @param inPeriodicLevel the number of level upper to 0 that will be requiried + */ FSphericalKernel(const int inDevP, const int inTreeHeight, const FReal inBoxWidth, const int inPeriodicLevel = 0) - : devP(inDevP), devM2lP(int(((inDevP*2)+1) * ((inDevP*2)+2) * 0.5)), boxWidth(inBoxWidth), - treeHeight(inTreeHeight), periodicLevels(inPeriodicLevel), harmonic(inDevP), - preL2LTransitions(0), preM2MTransitions(0), preM2LTransitions(0), - preL2LTransitionsPer(0), preM2MTransitionsPer(0), preM2LTransitionsPer(0) { - + : Parent(inDevP, inTreeHeight, inBoxWidth, inPeriodicLevel), + devM2lP(int(((inDevP*2)+1) * ((inDevP*2)+2) * 0.5)), preM2LTransitions(0) { allocAndInit(); - allocAndInitPer(); } /** Copy constructor */ FSphericalKernel(const FSphericalKernel& other) - : devP(other.devP), devM2lP(other.devM2lP), boxWidth(other.boxWidth), - treeHeight(other.treeHeight), periodicLevels(other.periodicLevels), harmonic(other.devP), - preL2LTransitions(0), preM2MTransitions(0), preM2LTransitions(0), - preL2LTransitionsPer(0), preM2MTransitionsPer(0), preM2LTransitionsPer(0) { - + : Parent(other), devM2lP(other.devM2lP), preM2LTransitions(0) { allocAndInit(); - allocAndInitPer(); } - /** Default destructor */ + /** Destructor */ ~FSphericalKernel(){ - delete[] preL2LTransitions; - delete[] preM2MTransitions; + FMemUtils::DeleteAll(preM2LTransitions, Parent::treeHeight + Parent::periodicLevels); delete[] preM2LTransitions; - - delete[] preL2LTransitionsPer; - delete[] preM2MTransitionsPer; - delete[] preM2LTransitionsPer; - } - - /** P2M with a cell and all its particles */ - void P2M(CellClass* const inPole, const ContainerClass* const inParticles) { - FComplexe* const cellMultiPole = inPole->getMultipole(); - // Copying the position is faster than using cell position - const F3DPosition polePosition = inPole->getPosition(); - // For all particles in the leaf box - typename ContainerClass::ConstBasicIterator iterParticle(*inParticles); - while( iterParticle.hasNotFinished()){ - // P2M - particleToMultiPole(cellMultiPole, polePosition, iterParticle.data()); - iterParticle.gotoNext(); - } - } - - /** M2M with a cell and all its child */ - void M2M(CellClass* const FRestrict inPole, const CellClass *const FRestrict *const FRestrict inChild, const int inLevel) { - FComplexe* const multipole_exp_target = inPole->getMultipole(); - // iter on each child and process M2M - if( inLevel >= 0){ - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ - if(inChild[idxChild]){ - multipoleToMultipole(multipole_exp_target, inChild[idxChild]->getMultipole(), &preM2MTransitions[indexTransition(inLevel,idxChild)]); - } - } - } - else{ - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ - if(inChild[idxChild]){ - multipoleToMultipole(multipole_exp_target, inChild[idxChild]->getMultipole(), &preM2MTransitionsPer[indexTransition(-1-inLevel,idxChild)]); - } - } - } } /** M2L with a cell and all the existing neighbors */ @@ -248,399 +91,33 @@ public: const int size, const int inLevel) { const FTreeCoordinate& coordCenter = pole->getCoordinate(); // For all neighbors compute M2L - if( inLevel >= 0){ - for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ - const FTreeCoordinate& coordNeighbors = distantNeighbors[idxNeigh]->getCoordinate(); - const FComplexe* const transitionVector = &preM2LTransitions[indexM2LTransition(inLevel, - (coordCenter.getX() - coordNeighbors.getX()), - (coordCenter.getY() - coordNeighbors.getY()), - (coordCenter.getZ() - coordNeighbors.getZ()))]; - - multipoleToLocal(pole->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); - } - } - else { - for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ - const FTreeCoordinate& coordNeighbors = distantNeighbors[idxNeigh]->getCoordinate(); - const FComplexe* const transitionVector = &preM2LTransitionsPer[indexM2LTransition(-1-inLevel, - (coordCenter.getX() - coordNeighbors.getX()), - (coordCenter.getY() - coordNeighbors.getY()), - (coordCenter.getZ() - coordNeighbors.getZ()))]; - - multipoleToLocal(pole->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); - } - } - } - - /** L2L with a cell and all its child */ - void L2L(const CellClass* const FRestrict pole, CellClass* FRestrict *const FRestrict child, const int inLevel) { - // iter on each child and process L2L - if( inLevel >= 0){ - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ - if(child[idxChild]){ - localToLocal(child[idxChild]->getLocal(), pole->getLocal(), &preL2LTransitions[indexTransition(inLevel,idxChild)]); - } - } - } - else{ - for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){ - if(child[idxChild]){ - localToLocal(child[idxChild]->getLocal(), pole->getLocal(), &preL2LTransitionsPer[indexTransition(-1-inLevel,idxChild)]); - } - } - } - } - - /** L2P with a cell and all its particles */ - void L2P(const CellClass* const local, ContainerClass* const particles){ - const FComplexe* const cellLocal = local->getLocal(); - // Copying the position is faster than using cell position - const F3DPosition localPosition = local->getPosition(); - // For all particles in the leaf box - typename ContainerClass::BasicIterator iterTarget(*particles); - while( iterTarget.hasNotFinished() ){ - // L2P - localToParticle(&iterTarget.data(), localPosition, cellLocal); - iterTarget.gotoNext(); - } - } - - /** This P2P has to be used when target != sources - * It will proceed an direct interation no mutual - * - * It takes all the target particles from the current leaf, - * then it computes the sources/targets interaction in this leaf, - * then it computes the sources/targets inteactions between this leaf and the - * neighbors. - */ - void P2P(ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict sources, - const ContainerClass* const directNeighbors[26], const int size) { - - { // Compute interaction in this leaf - typename ContainerClass::BasicIterator iterTarget(*targets); - while( iterTarget.hasNotFinished() ){ - // We copy the target particle to work with a particle in the heap - ParticleClass target( iterTarget.data() ); - - // For all the source particles in the same leaf - typename ContainerClass::ConstBasicIterator iterSameBox(*sources); - while( iterSameBox.hasNotFinished() ){ - //(&iterSameBox.data() != &iterTarget.data()) - directInteraction(&target, iterSameBox.data()); - iterSameBox.gotoNext(); - } - // Set data and progress - iterTarget.setData(target); - iterTarget.gotoNext(); - } - } - { // Compute interactions with other leaves - // For all the neigbors leaves - for(int idxDirectNeighbors = 0 ; idxDirectNeighbors < size ; ++idxDirectNeighbors){ - // For all particles in current leaf - typename ContainerClass::BasicIterator iterTarget(*targets); - while( iterTarget.hasNotFinished() ){ - ParticleClass target( iterTarget.data() ); - // For all the particles in the other leaf - typename ContainerClass::ConstBasicIterator iterSource(*directNeighbors[idxDirectNeighbors]); - while( iterSource.hasNotFinished() ){ - directInteraction(&target, iterSource.data()); - iterSource.gotoNext(); - } - // Set data and progress - iterTarget.setData(target); - iterTarget.gotoNext(); - } - } - } - } - - /** This P2P has to be used when target == sources - * It will proceed a direct interation >> mutual - * - * It takes all the particles from the current leaf, - * then it computes the interactions in this leaf, - * then it computes the inteactions between this leaf and the - * neighbors. - */ - void P2P(const MortonIndex inCurrentIndex, - ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict /*sources*/, - ContainerClass* const directNeighbors[26], const MortonIndex inNeighborsIndex[26], const int size){ - { // Compute interaction in this leaf - typename ContainerClass::BasicIterator iterTarget(*targets); - while( iterTarget.hasNotFinished() ){ - // We copy the target particle to work with a particle in the heap - ParticleClass target( iterTarget.data() ); + for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ + const FTreeCoordinate& coordNeighbors = distantNeighbors[idxNeigh]->getCoordinate(); + const FComplexe* const transitionVector = &preM2LTransitions[inLevel + Parent::periodicLevels] + [indexM2LTransition((coordCenter.getX() - coordNeighbors.getX()), + (coordCenter.getY() - coordNeighbors.getY()), + (coordCenter.getZ() - coordNeighbors.getZ()))]; - // For all particles after the current one - typename ContainerClass::BasicIterator iterSameBox = iterTarget; - iterSameBox.gotoNext(); - while( iterSameBox.hasNotFinished() ){ - directInteractionMutual(&target, &iterSameBox.data()); - iterSameBox.gotoNext(); - } - // Set data and progress - iterTarget.setData(target); - iterTarget.gotoNext(); - } - } - { // Compute interactions with other leaves - // For all the neigbors leaves - for(int idxDirectNeighbors = 0 ; idxDirectNeighbors < size ; ++idxDirectNeighbors){ - if(inCurrentIndex < inNeighborsIndex[idxDirectNeighbors] ){ - // For all particles in current leaf - typename ContainerClass::BasicIterator iterTarget(*targets); - while( iterTarget.hasNotFinished() ){ - ParticleClass target( iterTarget.data() ); - // For all the particles in the other leaf - typename ContainerClass::BasicIterator iterSource(*directNeighbors[idxDirectNeighbors]); - while( iterSource.hasNotFinished() ){ - directInteractionMutual(&target, &iterSource.data()); - iterSource.gotoNext(); - } - // Set data and progress - iterTarget.setData(target); - iterTarget.gotoNext(); - } - } - } + multipoleToLocal(pole->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); } } - /////////////////////////////////////////////////////////////////////////////// - // Periodic - /////////////////////////////////////////////////////////////////////////////// - /** Before Downward */ void M2L(CellClass* const FRestrict local, const CellClass* distantNeighbors[189], const FTreeCoordinate neighborsRelativePositions[189], const int size, const int inLevel) { // For all neighbors compute M2L for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ - const FComplexe* const transitionVector = &preM2LTransitions[indexM2LTransition(inLevel, - neighborsRelativePositions[idxNeigh].getX(), - neighborsRelativePositions[idxNeigh].getY(), - neighborsRelativePositions[idxNeigh].getZ())]; + const FComplexe* const transitionVector = &preM2LTransitions[inLevel + Parent::periodicLevels] + [indexM2LTransition(neighborsRelativePositions[idxNeigh].getX(), + neighborsRelativePositions[idxNeigh].getY(), + neighborsRelativePositions[idxNeigh].getZ())]; multipoleToLocal(local->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); } } - /** After Downward */ - void P2P(const MortonIndex inCurrentIndex, - ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict /*sources*/, - ContainerClass* const directNeighbors[26], const FTreeCoordinate neighborsRelativeOffset[26], const int size) { - - { // Compute interaction in this leaf - typename ContainerClass::BasicIterator iterTarget(*targets); - while( iterTarget.hasNotFinished() ){ - // We copy the target particle to work with a particle in the heap - ParticleClass target( iterTarget.data() ); - - // For all particles after the current one - typename ContainerClass::BasicIterator iterSameBox = iterTarget; - iterSameBox.gotoNext(); - while( iterSameBox.hasNotFinished() ){ - directInteractionMutual(&target, &iterSameBox.data()); - iterSameBox.gotoNext(); - } - // Set data and progress - iterTarget.setData(target); - iterTarget.gotoNext(); - } - } - { // Compute interactions with other leaves - // For all the neigbors leaves - for(int idxDirectNeighbors = 0 ; idxDirectNeighbors < size ; ++idxDirectNeighbors){ - // This box is not a real neighbor - if(neighborsRelativeOffset[idxDirectNeighbors].getX() || neighborsRelativeOffset[idxDirectNeighbors].getY() - || neighborsRelativeOffset[idxDirectNeighbors].getZ() ){ - typename ContainerClass::BasicIterator iterTarget(*targets); - while( iterTarget.hasNotFinished() ){ - ParticleClass target( iterTarget.data() ); - // For all the particles in the other leaf - typename ContainerClass::BasicIterator iterSource(*directNeighbors[idxDirectNeighbors]); - while( iterSource.hasNotFinished() ){ - directInteractionOffset(&target, iterSource.data(), neighborsRelativeOffset[idxDirectNeighbors]); - iterSource.gotoNext(); - } - // Set data and progress - iterTarget.setData(target); - iterTarget.gotoNext(); - } - } - // This is a real neighbor, we do as usual - else if(inCurrentIndex < neighborsRelativeOffset[idxDirectNeighbors].getMortonIndex(treeHeight) ){ - // For all particles in current leaf - typename ContainerClass::BasicIterator iterTarget(*targets); - while( iterTarget.hasNotFinished() ){ - ParticleClass target( iterTarget.data() ); - // For all the particles in the other leaf - typename ContainerClass::BasicIterator iterSource(*directNeighbors[idxDirectNeighbors]); - while( iterSource.hasNotFinished() ){ - directInteractionMutual(&target, &iterSource.data()); - iterSource.gotoNext(); - } - // Set data and progress - iterTarget.setData(target); - iterTarget.gotoNext(); - } - } - } - } - } - - /////////////////////////////////////////////////////////////////////////////// - // Computation - /////////////////////////////////////////////////////////////////////////////// -private: - - /** P2M computation - * expansion_P2M_add - * Multipole expansion with m charges q_i in Q_i=(rho_i, alpha_i, beta_i) - *whose relative coordinates according to *p_center are: - *Q_i - *p_center = (rho'_i, alpha'_i, beta'_i); - * - *For j=0..P, k=-j..j, we have: - * - *M_j^k = (-1)^j { sum{i=1..m} q_i Inner_j^k(rho'_i, alpha'_i, beta'_i) } - * - *However the extern loop is over the bodies (i=1..m) in our code and as an - *intern loop we have: j=0..P, k=-j..j - * - *and the potential is then given by: - * - * Phi(x) = sum_{n=0}^{+} sum_{m=-n}^{n} M_n^m O_n^{-m} (x - *p_center) - * - */ - void particleToMultiPole(FComplexe*const cellMultiPole, const F3DPosition& inPolePosition , - const ParticleClass& particle){ - - // Inner of Qi - Z0 => harmonic.result - harmonic.computeInner( FSpherical(particle.getPosition() - inPolePosition) ); - - FReal minus_one_pow_j = 1.0; // (-1)^j => be in turn 1 and -1 - const FReal qParticle = particle.getPhysicalValue(); // q in the formula - int index_j_k = 0; // p_exp_term & p_Y_term - - // J from 0 to P - for(int j = 0 ; j <= devP ; ++j){ - // k from 0 to J - for(int k = 0 ; k <= j ; ++k, ++index_j_k){ - harmonic.result(index_j_k).mulRealAndImag( qParticle * minus_one_pow_j ); - cellMultiPole[index_j_k] += harmonic.result(index_j_k); - - } - // (-1)^J => -1 becomes 1 or 1 becomes -1 - minus_one_pow_j = -minus_one_pow_j; - } - } - - /* M2M - *We compute the translation of multipole_exp_src from *p_center_of_exp_src to - *p_center_of_exp_target, and add the result to multipole_exp_target. - * - * O_n^l (with n=0..P, l=-n..n) being the former multipole expansion terms - * (whose center is *p_center_of_multipole_exp_src) we have for the new multipole - * expansion terms (whose center is *p_center_of_multipole_exp_target): - - * M_j^k = sum{n=0..j} - * sum{l=-n..n, |k-l|<=j-n} - * O_n^l Inner_{j-n}^{k-l}(rho, alpha, beta) - * - * where (rho, alpha, beta) are the spherical coordinates of the vector : - * p_center_of_multipole_exp_target - *p_center_of_multipole_exp_src - * - * Warning: if j-n < |k-l| we do nothing. - */ - void multipoleToMultipole(FComplexe* const FRestrict multipole_exp_target, - const FComplexe* const FRestrict multipole_exp_src, - const FComplexe* const FRestrict M2M_Inner_transfer){ - - // n from 0 to P - for(int n = 0 ; n <= devP ; ++n ){ - // l<0 // (-1)^l - FReal pow_of_minus_1_for_l = ( n & 1 ? FReal(-1.0) : FReal(1.0) ); - - // O_n^l : here points on the source multipole expansion term of degree n and order |l| - const int index_n = harmonic.getPreExpRedirJ(n); - - // l from -n to <0 - for(int l = -n ; l < 0 ; ++l){ - const FComplexe M_n__n_l = multipole_exp_src[index_n -l]; - - // j from n to P - for(int j = n ; j <= devP ; ++j ){ - // M_j^k - const int index_j = harmonic.getPreExpRedirJ(j); - // Inner_{j-n}^{k-l} : here points on the M2M transfer function/expansion term of degree n-j and order |k-l| - const int index_j_n = harmonic.getPreExpRedirJ(j-n); /* k==0 */ - - // since n-j+l<0 - for(int k = 0 ; k <= (j-n+l) ; ++k ){ // l<0 && k>=0 => k-l>0 - const FComplexe I_j_n__k_l = M2M_Inner_transfer[index_j_n + k - l]; - - multipole_exp_target[index_j + k].incReal( pow_of_minus_1_for_l * - ((M_n__n_l.getReal() * I_j_n__k_l.getReal()) + - (M_n__n_l.getImag() * I_j_n__k_l.getImag()))); - multipole_exp_target[index_j + k].incImag( pow_of_minus_1_for_l * - ((M_n__n_l.getReal() * I_j_n__k_l.getImag()) - - (M_n__n_l.getImag() * I_j_n__k_l.getReal()))); - - } // for k - } // for j - - pow_of_minus_1_for_l = -pow_of_minus_1_for_l; - } // for l - - // l from 0 to n - for(int l = 0 ; l <= n ; ++l){ - const FComplexe M_n__n_l = multipole_exp_src[index_n + l]; - - // j from n to P - for( int j = n ; j <= devP ; ++j ){ - const int first_k = FMath::Max(0,n-j+l); - // (-1)^k - FReal pow_of_minus_1_for_k = static_cast( first_k&1 ? -1.0 : 1.0 ); - // M_j^k - const int index_j = harmonic.getPreExpRedirJ(j); - // Inner_{j-n}^{k-l} : here points on the M2M transfer function/expansion term of degree n-j and order |k-l| - const int index_j_n = harmonic.getPreExpRedirJ(j-n); - - int k = first_k; - for(; k <= (j-n+l) && k < l ; ++k){ /* l>=0 && k-l<0 */ - const FComplexe I_j_n__l_k = M2M_Inner_transfer[index_j_n + l - k]; - - multipole_exp_target[index_j + k].incReal( pow_of_minus_1_for_k * pow_of_minus_1_for_l * - ((M_n__n_l.getReal() * I_j_n__l_k.getReal()) + - (M_n__n_l.getImag() * I_j_n__l_k.getImag()))); - multipole_exp_target[index_j + k].incImag(pow_of_minus_1_for_k * pow_of_minus_1_for_l * - ((M_n__n_l.getImag() * I_j_n__l_k.getReal()) - - (M_n__n_l.getReal() * I_j_n__l_k.getImag()))); - - pow_of_minus_1_for_k = -pow_of_minus_1_for_k; - } // for k - - for(/* k = l */; k <= (j - n + l) ; ++k){ // l>=0 && k-l>=0 - const FComplexe I_j_n__k_l = M2M_Inner_transfer[index_j_n + k - l]; - - multipole_exp_target[index_j + k].incReal( - (M_n__n_l.getReal() * I_j_n__k_l.getReal()) - - (M_n__n_l.getImag() * I_j_n__k_l.getImag())); - multipole_exp_target[index_j + k].incImag( - (M_n__n_l.getImag() * I_j_n__k_l.getReal()) + - (M_n__n_l.getReal() * I_j_n__k_l.getImag())); - - } // for k - } // for j - - pow_of_minus_1_for_l = -pow_of_minus_1_for_l; - } // for l - } // for n - } - - /** M2L *We compute the conversion of multipole_exp_src in *p_center_of_exp_src to *a local expansion in *p_center_of_exp_target, and add the result to local_exp_target. @@ -666,7 +143,7 @@ private: // L_j^k // HPMSTART(51, "M2L computation (loops)"); // j from 0 to P - for (int j = 0 ; j <= devP ; ++j){ + for (int j = 0 ; j <= Parent::devP ; ++j){ // (-1)^k FReal pow_of_minus_1_for_k = 1.0; //k from 0 to j @@ -677,12 +154,12 @@ private: // work with a local variable FComplexe L_j_k = local_exp[index_j_k]; // n from 0 to P - for (int n = 0 ; n <= /*devP or*/ devP-j ; ++n){ + for (int n = 0 ; n <= /*devP or*/ Parent::devP-j ; ++n){ // O_n^l : here points on the source multipole expansion term of degree n and order |l| - const int index_n = harmonic.getPreExpRedirJ(n); + const int index_n = Parent::harmonic.getPreExpRedirJ(n); // Outer_{j+n}^{-k-l} : here points on the M2L transfer function/expansion term of degree j+n and order |-k-l| - const int index_n_j = harmonic.getPreExpRedirJ(n+j); + const int index_n_j = Parent::harmonic.getPreExpRedirJ(n+j); FReal pow_of_minus_1_for_l = pow_of_minus_1_for_n; // (-1)^l @@ -740,346 +217,6 @@ private: }//k } } - - - /** L2L - *We compute the shift of local_exp_src from *p_center_of_exp_src to - *p_center_of_exp_target, and set the result to local_exp_target. - * - *O_n^l (with n=0..P, l=-n..n) being the former local expansion terms - *(whose center is *p_center_of_exp_src) we have for the new local - *expansion terms (whose center is *p_center_of_exp_target): - * - *L_j^k = sum{n=j..P} - *sum{l=-n..n} - *O_n^l Inner_{n-j}^{l-k}(rho, alpha, beta) - * - *where (rho, alpha, beta) are the spherical coordinates of the vector : - *p_center_of_exp_target - *p_center_of_exp_src - * - *Warning: if |l-k| > n-j, we do nothing. - */ - void localToLocal(FComplexe* const FRestrict local_exp_target, const FComplexe* const FRestrict local_exp_src, - const FComplexe* const FRestrict L2L_tranfer){ - // L_j^k - int index_j_k = 0; - - for (int j = 0 ; j <= devP ; ++j ){ - // (-1)^k - FReal pow_of_minus_1_for_k = 1.0; - - for (int k = 0 ; k <= j ; ++k, ++index_j_k ){ - FComplexe L_j_k = local_exp_target[index_j_k]; - - for (int n=j; n <= devP;++n){ - // O_n^l : here points on the source multipole expansion term of degree n and order |l| - const int index_n = harmonic.getPreExpRedirJ(n); - - int l = n - j + k; - // Inner_{n-j}^{l-k} : here points on the L2L transfer function/expansion term of degree n-j and order |l-k| - const int index_n_j = harmonic.getPreExpRedirJ(n-j); - - for(/*l = n - j + k*/ ; l-k > 0 ; --l){ /* l>0 && l-k>0 */ - const FComplexe L_j_l = local_exp_src[index_n + l]; - const FComplexe I_l_j__l_k = L2L_tranfer[index_n_j + l - k]; - - L_j_k.incReal( (L_j_l.getReal() * I_l_j__l_k.getReal()) - - (L_j_l.getImag() * I_l_j__l_k.getImag())); - L_j_k.incImag( (L_j_l.getImag() * I_l_j__l_k.getReal()) + - (L_j_l.getReal() * I_l_j__l_k.getImag())); - - } - - // (-1)^l - FReal pow_of_minus_1_for_l = ((l&1) ? FReal(-1.0) : FReal(1.0)); - for(/*l = k*/; l>0 && l>=j-n+k; --l){ /* l>0 && l-k<=0 */ - const FComplexe L_j_l = local_exp_src[index_n + l]; - const FComplexe I_l_j__l_k = L2L_tranfer[index_n_j - l + k]; - - L_j_k.incReal( pow_of_minus_1_for_l * pow_of_minus_1_for_k * - ((L_j_l.getReal() * I_l_j__l_k.getReal()) + - (L_j_l.getImag() * I_l_j__l_k.getImag()))); - L_j_k.incImag( pow_of_minus_1_for_l * pow_of_minus_1_for_k * - ((L_j_l.getImag() * I_l_j__l_k.getReal()) - - (L_j_l.getReal() * I_l_j__l_k.getImag()))); - - pow_of_minus_1_for_l = -pow_of_minus_1_for_l; - } - - // l<=0 && l-k<=0 - for(/*l = 0 ou l = j-n+k-1*/; l>=j-n+k; --l){ - const FComplexe L_j_l = local_exp_src[index_n - l]; - const FComplexe I_l_j__l_k = L2L_tranfer[index_n_j - l + k]; - - L_j_k.incReal( pow_of_minus_1_for_k * - ((L_j_l.getReal() * I_l_j__l_k.getReal()) - - (L_j_l.getImag() * I_l_j__l_k.getImag()))); - L_j_k.decImag( pow_of_minus_1_for_k * - ((L_j_l.getImag() * I_l_j__l_k.getReal()) + - (L_j_l.getReal() * I_l_j__l_k.getImag()))); - - } - }//n - - local_exp_target[index_j_k] = L_j_k; - - pow_of_minus_1_for_k = -pow_of_minus_1_for_k; - }//k - }//j - } - - /** L2P - */ - void localToParticle(ParticleClass*const particle, const F3DPosition& local_position, - const FComplexe*const local_exp){ - //--------------- Forces ----------------// - - FReal force_vector_in_local_base_x = 0; - FReal force_vector_in_local_base_y = 0; - FReal force_vector_in_local_base_z = 0; - - const FSpherical spherical(particle->getPosition() - local_position); - harmonic.computeInnerTheta( spherical ); - - int index_j_k = 1; - - for (int j = 1 ; j <= devP ; ++j ){ - { - // k=0: - // F_r: - const FReal exp_term_aux_real = ( (harmonic.result(index_j_k).getReal() * local_exp[index_j_k].getReal()) - (harmonic.result(index_j_k).getImag() * local_exp[index_j_k].getImag()) ); - //const FReal exp_term_aux_imag = ( (harmonic.result(index_j_k).getReal() * local_exp[index_j_k].getImag()) + harmonic.result(index_j_k).getImag() * local_exp[index_j_k].getReal()) ); - force_vector_in_local_base_x = ( force_vector_in_local_base_x + FReal(j) * exp_term_aux_real ); - } - { - // F_phi: k=0 => nothing to do for F_phi - // F_theta: - const FReal exp_term_aux_real = ( (harmonic.resultThetaDerivated(index_j_k).getReal() * local_exp[index_j_k].getReal()) - (harmonic.resultThetaDerivated(index_j_k).getImag() * local_exp[index_j_k].getImag()) ); - //const FReal exp_term_aux_imag = ( (harmonic.resultThetaDerivated(index_j_k).getReal() * local_exp[index_j_k].getImag()) + (harmonic.resultThetaDerivated(index_j_k).getImag() * local_exp[index_j_k].getReal()) ); - force_vector_in_local_base_y = ( force_vector_in_local_base_y + exp_term_aux_real ); - } - - ++index_j_k; - - // k>0: - for (int k=1; k<=j ;++k, ++index_j_k){ - { - // F_r: - const FReal exp_term_aux_real = ( (harmonic.result(index_j_k).getReal() * local_exp[index_j_k].getReal()) - (harmonic.result(index_j_k).getImag() * local_exp[index_j_k].getImag()) ); - const FReal exp_term_aux_imag = ( (harmonic.result(index_j_k).getReal() * local_exp[index_j_k].getImag()) + (harmonic.result(index_j_k).getImag() * local_exp[index_j_k].getReal()) ); - force_vector_in_local_base_x = (force_vector_in_local_base_x + FReal(2 * j) * exp_term_aux_real ); - // F_phi: - force_vector_in_local_base_z = ( force_vector_in_local_base_z - FReal(2 * k) * exp_term_aux_imag); - } - { - // F_theta: - const FReal exp_term_aux_real = ( (harmonic.resultThetaDerivated(index_j_k).getReal() * local_exp[index_j_k].getReal()) - (harmonic.resultThetaDerivated(index_j_k).getImag() * local_exp[index_j_k].getImag()) ); - //const FReal exp_term_aux_imag = ( (harmonic.resultThetaDerivated(index_j_k).getReal() * local_exp[index_j_k].getImag()) + (harmonic.resultThetaDerivated(index_j_k).getImag() * local_exp[index_j_k].getReal()) ); - force_vector_in_local_base_y = (force_vector_in_local_base_y + FReal(2.0) * exp_term_aux_real ); - } - - } - - } - // We want: - gradient(POTENTIAL_SIGN potential). - // The -(- 1.0) computing is not the most efficient programming ... - const FReal signe = 1.0; - if( FMath::Epsilon < spherical.getR()){ - force_vector_in_local_base_x = ( force_vector_in_local_base_x * signe / spherical.getR()); - force_vector_in_local_base_y = ( force_vector_in_local_base_y * signe / spherical.getR()); - force_vector_in_local_base_z = ( force_vector_in_local_base_z * signe / (spherical.getR() * spherical.getSinTheta())); - } - ///////////////////////////////////////////////////////////////////// - - //spherical_position_Set_ph - //FMB_INLINE COORDINATES_T angle_Convert_in_MinusPi_Pi(COORDINATES_T a){ - FReal ph = FMath::Fmod(spherical.getPhi(), FReal(2)*FMath::FPi); - if (ph > M_PI) ph -= FReal(2) * FMath::FPi; - if (ph < -M_PI + FMath::Epsilon) ph += FReal(2) * FMath::Epsilon; - - //spherical_position_Set_th - FReal th = FMath::Fmod(FMath::ACos(spherical.getCosTheta()), FReal(2) * FMath::FPi); - if (th < 0.0) th += 2*FMath::FPi; - if (th > FMath::FPi){ - th = 2*FMath::FPi - th; - //spherical_position_Set_ph(p, spherical_position_Get_ph(p) + M_PI); - ph = FMath::Fmod(ph + FMath::FPi, 2*FMath::FPi); - if (ph > M_PI) ph -= 2*FMath::FPi; - if (ph < -M_PI + FMath::Epsilon) ph += 2 * FMath::Epsilon; - th = FMath::Fmod(th, 2*FMath::FPi); - if (th > M_PI) th -= 2*FMath::FPi; - if (th < -M_PI + FMath::Epsilon) th += 2 * FMath::Epsilon; - } - //spherical_position_Set_r - //FReal rh = spherical.r; - if (spherical.getR() < 0){ - //rh = -spherical.r; - //spherical_position_Set_ph(p, M_PI - spherical_position_Get_th(p)); - ph = FMath::Fmod(FMath::FPi - th, 2*FMath::FPi); - if (ph > M_PI) ph -= 2*FMath::FPi; - if (ph < -M_PI + FMath::Epsilon) ph += 2 * FMath::Epsilon; - //spherical_position_Set_th(p, spherical_position_Get_th(p) + M_PI); - th = FMath::Fmod(th + FMath::FPi, 2*FMath::FPi); - if (th < 0.0) th += 2*FMath::FPi; - if (th > FMath::FPi){ - th = 2*FMath::FPi - th; - //spherical_position_Set_ph(p, spherical_position_Get_ph(p) + M_PI); - ph = FMath::Fmod(ph + FMath::FPi, 2*FMath::FPi); - if (ph > M_PI) ph -= 2*FMath::FPi; - if (ph < -M_PI + FMath::Epsilon) ph += 2 * FMath::Epsilon; - th = FMath::Fmod(th, 2*FMath::FPi); - if (th > M_PI) th -= 2*FMath::FPi; - if (th < -M_PI + FMath::Epsilon) th += 2 * FMath::Epsilon; - } - } - - const FReal cos_theta = FMath::Cos(th); - const FReal cos_phi = FMath::Cos(ph); - const FReal sin_theta = FMath::Sin(th); - const FReal sin_phi = FMath::Sin(ph); - - FReal force_vector_tmp_x = ( - cos_phi * sin_theta * force_vector_in_local_base_x + - cos_phi * cos_theta * force_vector_in_local_base_y + - (-sin_phi) * force_vector_in_local_base_z); - - FReal force_vector_tmp_y = ( - sin_phi * sin_theta * force_vector_in_local_base_x + - sin_phi * cos_theta * force_vector_in_local_base_y + - cos_phi * force_vector_in_local_base_z); - - FReal force_vector_tmp_z = ( - cos_theta * force_vector_in_local_base_x + - (-sin_theta) * force_vector_in_local_base_y); - - const FReal physicalValue = particle->getPhysicalValue(); - force_vector_tmp_x *= physicalValue; - force_vector_tmp_y *= physicalValue; - force_vector_tmp_z *= physicalValue; - - particle->incForces( force_vector_tmp_x, force_vector_tmp_y, force_vector_tmp_z ); - - //--------------- Potential ----------------// - - FReal result = 0.0; - index_j_k = 0; - - for(int j = 0 ; j<= devP ; ++j){ - // k=0 - harmonic.result(index_j_k) *= local_exp[index_j_k]; - result += harmonic.result(index_j_k).getReal(); - - ++index_j_k; - - // k>0 - for (int k = 1 ; k <= j ; ++k, ++index_j_k){ - harmonic.result(index_j_k) *= local_exp[index_j_k]; - result += 2 * harmonic.result(index_j_k).getReal(); - } - } - - particle->incPotential(result /* * physicalValue*/); - - } - -public: - /** P2P mutual interaction - * F = q * q' / r² - */ - void directInteractionMutual(ParticleClass*const FRestrict target, ParticleClass*const FRestrict source){ - - FReal dx = -(target->getPosition().getX() - source->getPosition().getX()); - FReal dy = -(target->getPosition().getY() - source->getPosition().getY()); - FReal dz = -(target->getPosition().getZ() - source->getPosition().getZ()); - - FReal inv_square_distance = FReal(1.0) / (dx*dx + dy*dy + dz*dz); - FReal inv_distance = FMath::Sqrt(inv_square_distance); - - inv_square_distance *= inv_distance; - inv_square_distance *= target->getPhysicalValue() * source->getPhysicalValue(); - - dx *= inv_square_distance; - dy *= inv_square_distance; - dz *= inv_square_distance; - - target->incForces( dx, dy, dz); - target->incPotential( inv_distance * source->getPhysicalValue() ); - - source->incForces( (-dx), (-dy), (-dz)); - source->incPotential( inv_distance * target->getPhysicalValue() ); - } - - /** P2P NO mutual interaction - * F = q * q' / r² - */ - void directInteraction(ParticleClass*const FRestrict target, const ParticleClass& source){ - - FReal dx = -(target->getPosition().getX() - source.getPosition().getX()); - FReal dy = -(target->getPosition().getY() - source.getPosition().getY()); - FReal dz = -(target->getPosition().getZ() - source.getPosition().getZ()); - - FReal inv_square_distance = FReal(1.0) / (dx*dx + dy*dy + dz*dz); - FReal inv_distance = FMath::Sqrt(inv_square_distance); - - inv_square_distance *= inv_distance; - inv_square_distance *= target->getPhysicalValue() * source.getPhysicalValue(); - - dx *= inv_square_distance; - dy *= inv_square_distance; - dz *= inv_square_distance; - - target->incForces( dx, dy, dz); - target->incPotential( inv_distance * source.getPhysicalValue() ); - } - - /** P2P NO mutual interaction with an offset - * F = q * q' / r² - */ - void directInteractionOffset(ParticleClass*const FRestrict target, const ParticleClass& source, const FTreeCoordinate& offset){ - - FReal dx = -(target->getPosition().getX() - source.getPosition().getX()) + FReal(offset.getX()) * boxWidth; - FReal dy = -(target->getPosition().getY() - source.getPosition().getY()) + FReal(offset.getY()) * boxWidth; - FReal dz = -(target->getPosition().getZ() - source.getPosition().getZ()) + FReal(offset.getZ()) * boxWidth; - - FReal inv_square_distance = FReal(1.0) / (dx*dx + dy*dy + dz*dz); - FReal inv_distance = FMath::Sqrt(inv_square_distance); - - inv_square_distance *= inv_distance; - inv_square_distance *= target->getPhysicalValue() * source.getPhysicalValue(); - - dx *= inv_square_distance; - dy *= inv_square_distance; - dz *= inv_square_distance; - - target->incForces( dx, dy, dz); - target->incPotential( inv_distance * source.getPhysicalValue() ); - } - - /** Update a velocity of a particle - * - */ - void computeVelocity(ParticleClass*const FRestrict target, const FReal DT){ - const FReal physicalValue = target->getPhysicalValue(); - // Coef = 1/m * time/2 - const FReal coef = (FReal(1.0)/physicalValue) * (DT/FReal(2.0)); - - // velocity = velocity + forces * coef - F3DPosition forces_coef(target->getForces()); - forces_coef *= coef; - target->incVelocity(forces_coef); - } - - /** Update a position of a particle - * - */ - void updatePosition(ParticleClass*const FRestrict target, const FReal DT){ - F3DPosition velocity_dt( target->getVelocity() ); - velocity_dt *= DT; - target->incPosition( velocity_dt ); - } }; - -#endif //FSPHERICALKERNEL_HPP - - +#endif // FSPHERICALKERNEL_HPP diff --git a/Src/Kernels/FSphericalParticle.hpp b/Src/Kernels/FSphericalParticle.hpp new file mode 100644 index 0000000000000000000000000000000000000000..b925392ac3bde8867673868544a3ffe925e97197 --- /dev/null +++ b/Src/Kernels/FSphericalParticle.hpp @@ -0,0 +1,27 @@ +// =================================================================================== +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. +// =================================================================================== +#ifndef FSPHERICALPARTICLE_HPP +#define FSPHERICALPARTICLE_HPP + +#include "../Extensions/FExtendForces.hpp" +#include "../Extensions/FExtendPotential.hpp" +#include "../Extensions/FExtendParticleType.hpp" +#include "../Components/FFmaParticle.hpp" + +class FSphericalParticle : public FExtendForces, public FFmaParticle, public FExtendPotential { +public: +}; + +class FTypedSphericalParticle : public FSphericalParticle, public FExtendParticleType { +public: +}; + +#endif // FSPHERICALPARTICLE_HPP diff --git a/Src/Kernels/FSphericalRotationKernel.hpp b/Src/Kernels/FSphericalRotationKernel.hpp new file mode 100644 index 0000000000000000000000000000000000000000..e9ae4d660126c29f86197de3f6549a024795d6df --- /dev/null +++ b/Src/Kernels/FSphericalRotationKernel.hpp @@ -0,0 +1,612 @@ +// =================================================================================== +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. +// =================================================================================== +#ifndef FSPHERICALROTATIONKERNEL_HPP +#define FSPHERICALROTATIONKERNEL_HPP + +#include "FAbstractSphericalKernel.hpp" +#include "../Utils/FMemUtils.hpp" + +/** +* @author Berenger Bramas (berenger.bramas@inria.fr) +* This class is the rotation spherical harmonic kernel +*/ +template< class ParticleClass, class CellClass, class ContainerClass> +class FSphericalRotationKernel : public FAbstractSphericalKernel { +protected: + typedef FAbstractSphericalKernel Parent; + + /** This class define some information to use rotation computation + */ + struct RotationInfo{ + FReal* rotation_a; + FReal* rotation_b; + + FComplexe* p_rot_multipole_exp; + FComplexe* p_rot_local_exp; + + /** Get z vector size */ + static int ZAxisExpensionSize(const int inDevP){ + return int( (inDevP&1) == 0 ? ((inDevP+1) + (inDevP*inDevP)*.25) : ((inDevP+1) + (inDevP*inDevP-1)*.25)); + } + + /** Constructor */ + RotationInfo(const int inDevP){ + rotation_a = new FReal[int( ((inDevP)+1) * ((inDevP)+2) * 0.5 )]; + for(int n = 0 ; n <= inDevP ; ++n){ + for(int m = 0 ; m <= n ; ++m){ + rotation_a[int(n*(n+1) * 0.5 + m)] = FMath::Sqrt( FReal((n+1+m)*(n+1-m)) / FReal(((2*n+1)*(2*n+3))) ); + } + } + rotation_b = new FReal[(inDevP+1) * (inDevP+1)]; + for(int n = 0 ; n <= inDevP ; ++n){ + for(int m = -n ; m < 0 ; ++m){ + rotation_b[n*(n+1) + m] = -FMath::Sqrt( FReal((n-m-1)*(n-m)) / FReal(((2*n-1)*(2*n+1))) ); + } + for(int m = 0 ; m <= n ; ++m){ + rotation_b[n*(n+1) + m] = FMath::Sqrt( FReal((n-m-1)*(n-m)) / FReal(((2*n-1)*(2*n+1))) ); + } + } + const int z_size = ZAxisExpensionSize(inDevP); + p_rot_multipole_exp = new FComplexe[z_size]; + p_rot_local_exp = new FComplexe[z_size]; + } + + /** Destructor */ + ~RotationInfo(){ + delete[] rotation_a; + delete[] rotation_b; + delete[] p_rot_multipole_exp; + delete[] p_rot_local_exp; + } + }; + + + /** This class holds the data need to do a M2L by rotation + * it is precomputed at the beginning + */ + struct RotationM2LTransfer { + const int devP; + const int expSize; + FComplexe** rcc_outer; + FComplexe** rcc_inner; + FReal* outer_array; + + /** Constructor */ + RotationM2LTransfer(const int inDevP, const int inDevM2lP, const int inExpSize) + : devP(inDevP), expSize(inExpSize){ + rcc_outer = new FComplexe*[devP + 1]; + rcc_inner = new FComplexe*[devP + 1]; + for( int idxP = 0 ; idxP <= devP ; ++idxP){ + const int rotationSize = ((idxP+1)*(2*idxP+1)); + rcc_outer[idxP] = new FComplexe[rotationSize]; + rcc_inner[idxP] = new FComplexe[rotationSize]; + } + outer_array = new FReal[inDevM2lP + 1]; + } + + /** Used in the initialisation */ + void spherical_harmonic_Outer_null_order_z_axis(const FReal r){ + const FReal inv_r = FReal(1.0 / r); + FReal tmp = inv_r; + + // l=0 + outer_array[0] = tmp; + + // l>0 + for(int l = 1 ; l <= devP ; ++l){ + tmp *= inv_r * FReal(l); + outer_array[l] = tmp; + } + } + + /** Used in the initialisation */ + void computeLegendre(const FReal inCosTheta, const FReal inSinTheta, FReal legendre[]){ + const FReal invSinTheta = -inSinTheta; + + legendre[0] = 1.0; // P_0,0(cosTheta) = 1 + legendre[1] = inCosTheta; // P_1,0(cosTheta) = cosTheta + legendre[2] = invSinTheta;// P_1,1(cosTheta) = -sinTheta + + int idxCurrentLM = 3; //current pointer on P_l,m + int idxCurrentL1M = 1; //pointer on P_{l-1},m => P_1,0 + int idxCurrentL2M = 0; //pointer on P_{l-2},m => P_0,0 + FReal fact = 3.0; + + for(int l = 2; l <= devP ; ++l ){ + // m from 0 to l - 2 + for( int m = 0; m <= l - 2 ; ++m ){ + legendre[idxCurrentLM] = (inCosTheta * FReal( 2 * l - 1 ) * legendre[idxCurrentL1M] + - FReal( l + m - 1 ) * legendre[idxCurrentL2M] ) + / FReal( l - m ); + + + // progress + ++idxCurrentLM; + ++idxCurrentL1M; + ++idxCurrentL2M; + } + + // Compute P_l,{l-1} + legendre[idxCurrentLM++] = inCosTheta * FReal( 2 * l - 1 ) * legendre[idxCurrentL1M]; + + // Compute P_l,l + legendre[idxCurrentLM++] = fact * invSinTheta * legendre[idxCurrentL1M]; + + fact += FReal(2.0); + ++idxCurrentL1M; + } + } + + /** Used in the initialisation */ + static int getTranspRotationCoefP(const int n, const int nu, const int m){ + return m*(2*n+1) + (nu+n); + } + /** Used in the initialisation */ + static int getRotationCoefP(const int n, const int nu, const int m){ + return (nu)*(2*(n)+1) + (m+n); + } + /** Used in the initialisation */ + static int getRotationB(const int n, const int m){ + return n*(n+1) + m; + } + /** Used in the initialisation */ + static int getRotationA(const int n, const int m){ + return int(n*(n+1) * 0.5 + (FMath::Abs(m))); + } + + /** Used in the initialisation */ + static FReal A_div_A(int n, int m, int nu){ + m = FMath::Abs(m); + nu = FMath::Abs(nu); + const int min = FMath::Min(m, nu); + const int max = FMath::Max(m, nu); + const int i_stop = max - min - 1; /* = n-min - (n-max+1) = n+max - (n+min+1) */ + + FReal num = FReal(n-max+1); + FReal denom = FReal(n+min+1); + FReal A_min_max = 1; + for (int i=0; i<=i_stop; ++i, ++num, ++denom){ + A_min_max *= (num/denom); + } + + if (nu == min) + return FMath::Sqrt(A_min_max); + else + return 1/FMath::Sqrt(A_min_max); + } + + /** Pre-Compute */ + void rotation_coefficient_container_Fill(const FReal omega, + const FReal cos_gamma, const FReal sin_gamma, + const FReal chi, const RotationInfo& rotation_Info){ + + FComplexe** rcc_tmp_transposed = new FComplexe*[devP + 1]; + for( int idxP = 0 ; idxP <= devP ; ++idxP){ + const int rotationSize = ((idxP+1)*(2*idxP+1)); + rcc_tmp_transposed[idxP] = new FComplexe[rotationSize]; + } + + FComplexe _pow_of_I_array[7]; + _pow_of_I_array[0].setRealImag(0 , 1 ) /* I^{-3} */; + _pow_of_I_array[1].setRealImag(-1, 0 ) /* I^{-2} */; + _pow_of_I_array[2].setRealImag(0 , -1) /* I^{-1} */; + _pow_of_I_array[3].setRealImag(1 , 0 ) /* I^0 */; + _pow_of_I_array[4].setRealImag(0 , 1 ) /* I^1 */; + _pow_of_I_array[5].setRealImag(-1, 0 ) /* I^2 */; + _pow_of_I_array[6].setRealImag(0 , -1) /* I^3 */; + + const FComplexe* pow_of_I_array = _pow_of_I_array + 3; /* points on I^0 */ + + FComplexe* const _precomputed_exp_I_chi_array = new FComplexe[2*devP + 1]; + FComplexe* precomputed_exp_I_chi_array = _precomputed_exp_I_chi_array + devP; + + FComplexe* const _precomputed_exp_I_omega_array = new FComplexe[2*devP + 1]; + FComplexe* precomputed_exp_I_omega_array = _precomputed_exp_I_omega_array + devP; + + + // cos(x) = sin(x + Pi/2) + for(int m = -devP ; m <= devP ; ++m){ + precomputed_exp_I_chi_array[m].setReal(FMath::Sin(FReal(m)*chi + FMath::FPiDiv2)); + precomputed_exp_I_chi_array[m].setImag(FMath::Sin(FReal(m)*chi)); + } + for(int nu = -devP ; nu <= devP ; ++nu){ + precomputed_exp_I_omega_array[nu].setReal(FMath::Sin(FReal(nu)*omega + FMath::FPiDiv2)); + precomputed_exp_I_omega_array[nu].setImag(FMath::Sin(FReal(nu)*omega)); + } + + FReal*const ass_Legendre_func_Array = new FReal[expSize]; + FReal* p_ass_Legendre_func_Array = ass_Legendre_func_Array; + computeLegendre(cos_gamma, sin_gamma, ass_Legendre_func_Array); + + for(int n = 0 ; n <= devP ; ++n){ + // nu == 0: + FReal c_n_nu = 1; + rcc_tmp_transposed[n][getTranspRotationCoefP(n,0,0)].setReal(c_n_nu * (*p_ass_Legendre_func_Array)); + + ++p_ass_Legendre_func_Array; + + // nu > 0: + FReal minus_1_pow_nu = -1; + for(int nu = 1 ; nu <= n; ++nu){ + c_n_nu /= FMath::Sqrt(FReal((n-nu+1)*(n+nu))); + rcc_tmp_transposed[n][getTranspRotationCoefP(n, nu, 0)].setReal(minus_1_pow_nu * c_n_nu * (*p_ass_Legendre_func_Array)); + rcc_tmp_transposed[n][getTranspRotationCoefP(n, -nu, 0)] = rcc_tmp_transposed[n][getTranspRotationCoefP(n, nu, 0)]; + minus_1_pow_nu = -minus_1_pow_nu; + ++p_ass_Legendre_func_Array; + } // for nu + + for(int m = 1 ; m <= n ; ++m){ + for(int nu = -m; nu <= m ; ++nu){ + const FReal H_nu_minus_1 = ( nu-1 <= -n ? + FReal(0.0) : + (cos_gamma +1) * rotation_Info.rotation_b[getRotationB(n, -nu)] + * rcc_tmp_transposed[n-1][getTranspRotationCoefP(n-1, nu-1, m-1)].getReal()); + const FReal H_nu_plus_1 = ( nu+1 >= n ? + FReal(0.0) : + (cos_gamma -1) * rotation_Info.rotation_b[getRotationB(n, nu)] + * rcc_tmp_transposed[n-1][getTranspRotationCoefP(n-1, nu+1, m-1)].getReal()); + + const FReal H_nu = ( FMath::Abs(nu) >= n ? + FReal(0.0) : + sin_gamma * rotation_Info.rotation_a[getRotationA(n-1, nu)] + * rcc_tmp_transposed[n-1][getTranspRotationCoefP(n-1, nu, m-1)].getReal() ); + + + rcc_tmp_transposed[n][getTranspRotationCoefP(n, nu, m)].setReal( (FReal(0.5) * (-H_nu_minus_1 - H_nu_plus_1) - H_nu) + / rotation_Info.rotation_b[getRotationB(n, -m)]); + } // for nu + } // for m + + for(int m = 1 ; m <= n ; ++m){ + for(int nu = -n ; nu <= -m-1; ++nu){ + rcc_tmp_transposed[n][getTranspRotationCoefP(n, nu, m)] = rcc_tmp_transposed[n][getTranspRotationCoefP(n, -m, -nu)]; + } // for nu + + for(int nu = m+1 ; nu <= n; ++nu){ + rcc_tmp_transposed[n][getTranspRotationCoefP(n, nu, m)] = rcc_tmp_transposed[n][getTranspRotationCoefP(n, m, nu)]; + } // for nu + } // for m + } // for n + + for(int n = 0 ; n <= devP ; ++n){ + for(int nu = 0 ; nu <= n; ++nu){ + for(int m = -n; m <= n; ++m){ + FReal A_terms = A_div_A(n, m, nu); /* A_n^m / A_n^nu */ + int abs_m_minus_abs_nu_mod4 = (FMath::Abs(m) - FMath::Abs(nu)) % 4; /* can be negative! */ + const FComplexe p_H_tmp = ( m >= 0 ? + rcc_tmp_transposed[n][getTranspRotationCoefP(n, nu, m)] : + rcc_tmp_transposed[n][getTranspRotationCoefP(n, -nu, -m)]) ; + + /*************** T_Outer_n^{nu, m}(omega, gamma, chi): ***************/ + rcc_outer[n][getRotationCoefP(n, nu, m)] = p_H_tmp; + /* H_n^{nu, m}(gamma) => T_n^{nu, m}(omega, gamma, chi) */ + rcc_outer[n][getRotationCoefP(n, nu, m)] *= precomputed_exp_I_chi_array[ + m]; + rcc_outer[n][getRotationCoefP(n, nu, m)] *= precomputed_exp_I_omega_array[ - nu]; + /* T_Outer_j^{nu, k}(omega, gamma, chi) = i^{|k|-|nu|} (A_j^nu / A_j^k) T_j^{nu, k}(omega, gamma, chi) (6) */ + rcc_outer[n][getRotationCoefP(n, nu, m)] *= pow_of_I_array[abs_m_minus_abs_nu_mod4]; + rcc_outer[n][getRotationCoefP(n, nu, m)] *= (FReal(1.0) / A_terms); + + + /*************** T_Inner_n^{nu, m}(chi, gamma, omega): ***************/ + rcc_inner[n][getRotationCoefP(n, nu, m)] = p_H_tmp; + /* H_n^{nu, m}(gamma) => T_n^{nu, m}(chi, gamma, omega) */ + rcc_inner[n][getRotationCoefP(n, nu, m)] *= precomputed_exp_I_omega_array[ + m]; + rcc_inner[n][getRotationCoefP(n, nu, m)] *= precomputed_exp_I_chi_array[ - nu]; + /* T_Inner_j^{nu, k}(omega, gamma, chi) = i^{|nu|-|k|} (A_j^k / A_j^nu) T_j^{nu, k}(omega, gamma, chi) (7) */ + rcc_inner[n][getRotationCoefP(n, nu, m)] *= pow_of_I_array[- abs_m_minus_abs_nu_mod4]; + rcc_inner[n][getRotationCoefP(n, nu, m)] *= A_terms; + + }// for m + } // for nu + } // for n + + + delete[] (ass_Legendre_func_Array); + delete[] (_precomputed_exp_I_chi_array); + delete[] (_precomputed_exp_I_omega_array); + FMemUtils::DeleteAll( rcc_tmp_transposed, devP); + delete[] rcc_tmp_transposed; + } + + /** Pre-compute */ + void transfer_M2L_rotation_Fill(const FSpherical& inSphere, const RotationInfo& rotation_Info){ + + // Computes rotation coefficients: + rotation_coefficient_container_Fill(FMath::FPi, inSphere.getCosTheta(), + inSphere.getSinTheta(), inSphere.getPhi(), rotation_Info); + + // Computes Outer terms: + spherical_harmonic_Outer_null_order_z_axis(inSphere.getR()); + + + } + + ~RotationM2LTransfer(){ + FMemUtils::DeleteAll( rcc_outer, devP); + FMemUtils::DeleteAll( rcc_inner, devP); + delete[] rcc_outer; + delete[] rcc_inner; + delete[] outer_array; + } + }; + + const int devM2lP; //< A secondary P + + RotationM2LTransfer** preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities + RotationInfo rotation_Info; + + /** To access te pre computed M2L transfer vector */ + int indexM2LTransition(const int idxX,const int idxY,const int idxZ) const { + return (((((idxX+3) * 7) + (idxY+3)) * 7 ) + (idxZ+3)) * devM2lP; + } + + /** Alloc and init pre-vectors*/ + void allocAndInit(){ + // M2L transfer, there is a maximum of 3 neighbors in each direction, + // so 6 in each dimension + preM2LTransitions = new RotationM2LTransfer*[Parent::treeHeight + Parent::periodicLevels]; + memset(preM2LTransitions, 0, sizeof(FComplexe*) * (Parent::treeHeight + Parent::periodicLevels)); + // We start from the higher level + FReal treeWidthAtLevel = Parent::boxWidth * FReal(1 << Parent::periodicLevels); + for(int idxLevel = -Parent::periodicLevels ; idxLevel < Parent::treeHeight ; ++idxLevel ){ + // Allocate data for this level + preM2LTransitions[idxLevel + Parent::periodicLevels] = reinterpret_cast(new char[(7 * 7 * 7) * devM2lP * sizeof(RotationM2LTransfer)]); + // Precompute transfer vector + for(int idxX = -3 ; idxX <= 3 ; ++idxX ){ + for(int idxY = -3 ; idxY <= 3 ; ++idxY ){ + for(int idxZ = -3 ; idxZ <= 3 ; ++idxZ ){ + new (&preM2LTransitions[idxLevel + Parent::periodicLevels][indexM2LTransition(idxX,idxY,idxZ)]) RotationM2LTransfer(Parent::devP,devM2lP,Parent::harmonic.getExpSize()); + + if(FMath::Abs(idxX) > 1 || FMath::Abs(idxY) > 1 || FMath::Abs(idxZ) > 1){ + const F3DPosition relativePos( FReal(idxX) * treeWidthAtLevel , FReal(idxY) * treeWidthAtLevel , FReal(idxZ) * treeWidthAtLevel ); + preM2LTransitions[idxLevel + Parent::periodicLevels][indexM2LTransition(idxX,idxY,idxZ)].transfer_M2L_rotation_Fill(FSpherical(relativePos), rotation_Info); + } + } + } + } + // We divide the bow per 2 when we go down + treeWidthAtLevel /= 2; + } + } + + +public: + /** Constructor + * @param inDevP the polynomial degree + * @param inThreeHeight the height of the tree + * @param inBoxWidth the size of the simulation box + * @param inPeriodicLevel the number of level upper to 0 that will be requiried + */ + FSphericalRotationKernel(const int inDevP, const int inTreeHeight, const FReal inBoxWidth, const int inPeriodicLevel = 0) + : Parent(inDevP, inTreeHeight, inBoxWidth, inPeriodicLevel), + devM2lP(int(((inDevP*2)+1) * ((inDevP*2)+2) * 0.5)), preM2LTransitions(0), rotation_Info(inDevP) { + allocAndInit(); + } + + /** Copy constructor */ + FSphericalRotationKernel(const FSphericalRotationKernel& other) + : Parent(other), devM2lP(other.devM2lP), preM2LTransitions(0), rotation_Info(other.devP) { + allocAndInit(); + } + + /** Destructor */ + ~FSphericalRotationKernel(){ + for(int idxLevel = -Parent::periodicLevels ; idxLevel < Parent::treeHeight ; ++idxLevel ){ + for(int idx = 0 ; idx < 7*7*7 ; ++idx ){ + preM2LTransitions[idxLevel + Parent::periodicLevels][idx].~RotationM2LTransfer(); + } + delete[] reinterpret_cast(preM2LTransitions[idxLevel + Parent::periodicLevels]); + } + delete[] preM2LTransitions; + } + + /** M2L with a cell and all the existing neighbors */ + void M2L(CellClass* const FRestrict pole, const CellClass* distantNeighbors[189], + const int size, const int inLevel) { + const FTreeCoordinate& coordCenter = pole->getCoordinate(); + // For all neighbors compute M2L + for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ + const FTreeCoordinate& coordNeighbors = distantNeighbors[idxNeigh]->getCoordinate(); + const RotationM2LTransfer& transitionVector = preM2LTransitions[inLevel + Parent::periodicLevels] + [indexM2LTransition((coordCenter.getX() - coordNeighbors.getX()), + (coordCenter.getY() - coordNeighbors.getY()), + (coordCenter.getZ() - coordNeighbors.getZ()))]; + + multipoleToLocal(pole->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); + } + } + + /** Before Downward */ + void M2L(CellClass* const FRestrict local, const CellClass* distantNeighbors[189], + const FTreeCoordinate neighborsRelativePositions[189], + const int size, const int inLevel) { + // For all neighbors compute M2L + for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){ + const RotationM2LTransfer& transitionVector = preM2LTransitions[inLevel + Parent::periodicLevels] + [indexM2LTransition(neighborsRelativePositions[idxNeigh].getX(), + neighborsRelativePositions[idxNeigh].getY(), + neighborsRelativePositions[idxNeigh].getZ())]; + + multipoleToLocal(local->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector); + } + } + + + /** M2L With rotation + */ + void multipoleToLocal(FComplexe*const FRestrict local_exp_target, const FComplexe* const FRestrict multipole_exp_src, + const RotationM2LTransfer& transfer_M2L_rotation){ + + memset(rotation_Info.p_rot_multipole_exp, 0, RotationInfo::ZAxisExpensionSize(Parent::devP) * sizeof(FComplexe)); + memset(rotation_Info.p_rot_local_exp, 0, RotationInfo::ZAxisExpensionSize(Parent::devP) * sizeof(FComplexe)); + + rotation_Rotate_multipole_expansion_terms(multipole_exp_src, transfer_M2L_rotation.rcc_outer, rotation_Info.p_rot_multipole_exp); + + M2L_z_axis(rotation_Info.p_rot_local_exp, rotation_Info.p_rot_multipole_exp, transfer_M2L_rotation.outer_array); + + rotation_Rotate_local_expansion_terms(rotation_Info.p_rot_local_exp, transfer_M2L_rotation.rcc_inner, local_exp_target); + } + + /** Needed when doing the M2L */ + void rotation_Rotate_multipole_expansion_terms(const FComplexe*const FRestrict multipole_exp, + const FComplexe* const FRestrict * const FRestrict rcc_outer, + FComplexe*const FRestrict rot_multipole_exp){ + + FComplexe* p_rot_multipole_exp = rot_multipole_exp; + + for(int nu = 0 ; nu <= (Parent::devP/2) ; ++nu){ + for(int j = nu; j <= (Parent::devP-nu) ; ++j){ + const FComplexe* p_rcc_outer = &rcc_outer[j][RotationM2LTransfer::getRotationCoefP(j, nu, j)]; + const FComplexe* p_multipole_exp = &multipole_exp[Parent::harmonic.getPreExpRedirJ(j) + j]; + FReal minus_1_pow_k = FReal(j&1 ? -1 : 1); + + for(int k = -j ; k < 0 ; ++k){ /* k < 0 */ + p_rot_multipole_exp->incReal( minus_1_pow_k * + ((p_multipole_exp->getReal() * p_rcc_outer->getReal()) + + (p_multipole_exp->getImag() * p_rcc_outer->getImag())) ); + p_rot_multipole_exp->incImag( minus_1_pow_k * + ((p_multipole_exp->getReal() * p_rcc_outer->getImag()) - + (p_multipole_exp->getImag() * p_rcc_outer->getReal())) ); + + minus_1_pow_k = -minus_1_pow_k; + --p_rcc_outer; + --p_multipole_exp; + } /* for k */ + + for(int k = 0; k <= j ; ++k){ /* k >= 0 */ + p_rot_multipole_exp->incReal( + ((p_multipole_exp->getReal() * p_rcc_outer->getReal()) - + (p_multipole_exp->getImag() * p_rcc_outer->getImag())) ); + p_rot_multipole_exp->incImag( + ((p_multipole_exp->getReal() * p_rcc_outer->getImag()) + + (p_multipole_exp->getImag() * p_rcc_outer->getReal())) ); + + --p_rcc_outer; + ++p_multipole_exp; + } /* for k */ + + ++p_rot_multipole_exp; + } /* for j */ + } /* for nu */ + } + + /** Needed when doing the M2L */ + void M2L_z_axis(FComplexe* const FRestrict rot_local_exp, + const FComplexe* const FRestrict rot_multipole_exp, + const FReal* const outer_array){ + FComplexe* p_rot_local_exp = rot_local_exp; + + for(int j = 0 ; j <= Parent::devP; ++j){ + const FReal* p_outer_array_j = outer_array + j; + const int stop_for_n = Parent::devP-j; + const int min_j = FMath::Min(j, stop_for_n); + for(int k = 0 ; k <= min_j ; ++k){ + const FComplexe* p_rot_multipole_exp = rot_multipole_exp + k * (Parent::devP + 2 - k); + for(int n = k ; n <= stop_for_n ; ++n){ + p_rot_local_exp->incReal(p_rot_multipole_exp->getReal() * p_outer_array_j[n]); + p_rot_local_exp->incImag(p_rot_multipole_exp->getImag() * p_outer_array_j[n]); + ++p_rot_multipole_exp; + } /* for n */ + ++p_rot_local_exp; + } /* for k */ + } /* for j */ + } + + /** Needed when doing the M2L */ + void rotation_Rotate_local_expansion_terms(const FComplexe*const rot_local_exp, + const FComplexe*const FRestrict *const FRestrict rcc_inner, + FComplexe*const FRestrict local_exp){ + const int Q = Parent::devP/2; + + FComplexe* FRestrict p_local_exp = local_exp; + + for(int j = 0 ; j <= Q ; ++j){ + const int min_j = j; + const FComplexe* const FRestrict p_rot_local_exp_j = &rot_local_exp[Parent::harmonic.getPreExpRedirJ(j) + j]; + + for (int nu = 0 ; nu <= j; ++nu){ + const FComplexe* FRestrict p_rcc_inner = &rcc_inner[j][RotationM2LTransfer::getRotationCoefP(j, nu, -min_j)]; + const FComplexe* FRestrict p_rot_local_exp = p_rot_local_exp_j; + FReal minus_1_pow_k = FReal(min_j&1 ? -1 : 1); + + for(int k = -min_j ; k < 0 ; ++k){ /* k < 0 */ + p_local_exp->incReal( minus_1_pow_k * + ((p_rot_local_exp->getReal() * p_rcc_inner->getReal()) + + (p_rot_local_exp->getImag() * p_rcc_inner->getImag()))); + p_local_exp->incImag( minus_1_pow_k * + ((p_rot_local_exp->getReal() * p_rcc_inner->getImag()) - + (p_rot_local_exp->getImag() * p_rcc_inner->getReal()))); + + minus_1_pow_k = -minus_1_pow_k; + --p_rot_local_exp; + ++p_rcc_inner; + } /* for k */ + + for(int k = 0; k <= min_j ; ++k){ /* k >= 0 */ + p_local_exp->incReal( + ((p_rot_local_exp->getReal() * p_rcc_inner->getReal()) - + (p_rot_local_exp->getImag() * p_rcc_inner->getImag()))); + p_local_exp->incImag( + ((p_rot_local_exp->getReal() * p_rcc_inner->getImag()) + + (p_rot_local_exp->getImag() * p_rcc_inner->getReal()))); + + ++p_rot_local_exp; + ++p_rcc_inner; + } /* for k */ + + + ++p_local_exp; + } /* for nu */ + } /* for j */ + + const FComplexe* FRestrict p_rot_local_exp_j = &rot_local_exp[Parent::harmonic.getPreExpRedirJ(Q) + Q]; + + for(int j = Q + 1; j <= Parent::devP ; ++j){ + p_rot_local_exp_j += Parent::devP - j +1; + const int min_j = Parent::devP-j; + + for(int nu = 0 ; nu <= j; ++nu){ + const FComplexe* FRestrict p_rcc_inner = &rcc_inner[j][RotationM2LTransfer::getRotationCoefP(j, nu, -min_j)]; + const FComplexe* FRestrict p_rot_local_exp = p_rot_local_exp_j; + FReal minus_1_pow_k = FReal(min_j&1 ? -1 : 1); + + for(int k = -min_j ; k < 0; ++k){ /* k < 0 */ + p_local_exp->incReal( minus_1_pow_k * + ((p_rot_local_exp->getReal() * p_rcc_inner->getReal()) + + (p_rot_local_exp->getImag() * p_rcc_inner->getImag()))); + p_local_exp->incImag( minus_1_pow_k * + ((p_rot_local_exp->getReal() * p_rcc_inner->getImag()) - + (p_rot_local_exp->getImag() * p_rcc_inner->getReal()))); + + minus_1_pow_k = -minus_1_pow_k; + --p_rot_local_exp; + ++p_rcc_inner; + } /* for k */ + for(int k = 0; k<=min_j; ++k){ /* k >= 0 */ + p_local_exp->incReal( + ((p_rot_local_exp->getReal() * p_rcc_inner->getReal()) - + (p_rot_local_exp->getImag() * p_rcc_inner->getImag()))); + p_local_exp->incImag( + ((p_rot_local_exp->getReal() * p_rcc_inner->getImag()) + + (p_rot_local_exp->getImag() * p_rcc_inner->getReal()))); + + ++p_rot_local_exp; + ++p_rcc_inner; + } /* for k */ + ++p_local_exp; + } /* for nu */ + } /* for j */ + } +}; + + + +#endif // FSPHERICALROTATIONKERNEL_HPP diff --git a/Src/Utils/F3DPosition.hpp b/Src/Utils/F3DPosition.hpp index 69349f2a40946dfbc2b06cb03789c950a38e2f2a..b876a1b434c6d83cbb536b01641c06255c479515 100644 --- a/Src/Utils/F3DPosition.hpp +++ b/Src/Utils/F3DPosition.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef F3DPOSITION_HPP #define F3DPOSITION_HPP diff --git a/Src/Utils/FAbstractSendable.hpp b/Src/Utils/FAbstractSendable.hpp index 12c5a636059e1f73126d9c2d7d9f706cf0930a7e..e260c08f238ef76b0ac07e75a919dc2b310e36fe 100644 --- a/Src/Utils/FAbstractSendable.hpp +++ b/Src/Utils/FAbstractSendable.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FABSTRACTSENDABLE_HPP #define FABSTRACTSENDABLE_HPP diff --git a/Src/Utils/FAssertable.hpp b/Src/Utils/FAssertable.hpp index 7dd09fd855bdb00588c00b6bd087cfb76cc655f7..884e41d59232f45eb074a69d69f3f8535c8ad2e4 100644 --- a/Src/Utils/FAssertable.hpp +++ b/Src/Utils/FAssertable.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FASSERTABLE_HPP #define FASSERTABLE_HPP diff --git a/Src/Utils/FBitonicSort.hpp b/Src/Utils/FBitonicSort.hpp index 34f1d716c167166a2e3d15eb3b7865758aa6c2b6..775ca2561fd98b63bdcb450b9c8d22abec876f24 100644 --- a/Src/Utils/FBitonicSort.hpp +++ b/Src/Utils/FBitonicSort.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef BITONICSORT_HPP #define BITONICSORT_HPP diff --git a/Src/Utils/FBlas.hpp b/Src/Utils/FBlas.hpp index 908b59cc8e675dc3fa54db891bdf88a8eb67d9e3..65c4add4a621e00edd31741c8a805a28359ef9df 100644 --- a/Src/Utils/FBlas.hpp +++ b/Src/Utils/FBlas.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FBLAS_HPP #define FBLAS_HPP diff --git a/Src/Utils/FComplexe.hpp b/Src/Utils/FComplexe.hpp index 15acf660650b36ca6670bed43efeeda8bc9cfa24..f183411a6770fd098f8b56e8f5f9a9a4c82f71fc 100644 --- a/Src/Utils/FComplexe.hpp +++ b/Src/Utils/FComplexe.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FCOMPLEXE_HPP #define FCOMPLEXE_HPP @@ -162,6 +157,13 @@ public: return *this; } + /** Mul a complexe by another "c*=c2" */ + FComplexe& operator*=(const FReal& real){ + this->complex[0] *= real; + this->complex[1] *= real; + return *this; + } + /** Test if a complex is not a number */ bool isNan() const { return FMath::IsNan(complex[1]) || FMath::IsNan(complex[0]); diff --git a/Src/Utils/FDebug.cpp b/Src/Utils/FDebug.cpp index 50683d257cccceb3141777d7899a562c6e2a35e0..d2bf1583c41f62a96e9fcea55d8ff7403aa41eca 100644 --- a/Src/Utils/FDebug.cpp +++ b/Src/Utils/FDebug.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FDebug.hpp" #ifdef SCALFMM_USE_DEBUG diff --git a/Src/Utils/FDebug.hpp b/Src/Utils/FDebug.hpp index 2283d4574b5f7283109b467da7e6f83636ce5c9e..42c7650f4e09b2e63be9f97c7c3a7b2692a30ea7 100644 --- a/Src/Utils/FDebug.hpp +++ b/Src/Utils/FDebug.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FDEBUG_HPP #define FDEBUG_HPP diff --git a/Src/Utils/FGlobal.hpp b/Src/Utils/FGlobal.hpp index 216cf30fa93fa0d9241380fd46eaf471f7ea47ef..58a401101a6e32482dd1ec1ebb48280026d2af06 100644 --- a/Src/Utils/FGlobal.hpp +++ b/Src/Utils/FGlobal.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FGLOBAL_HPP #define FGLOBAL_HPP diff --git a/Src/Utils/FMath.cpp b/Src/Utils/FMath.cpp index 8e278984f0523de83f8d4e81925073844bd95e02..00c9bba746949784eef5538608fd103c611285b1 100644 --- a/Src/Utils/FMath.cpp +++ b/Src/Utils/FMath.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FMath.hpp" diff --git a/Src/Utils/FMath.hpp b/Src/Utils/FMath.hpp index 4f47105db795680481b9d2a6b47d5e9863752498..afed00ee7f1a3982d5f8420e3bc2b5f64dd0fca7 100644 --- a/Src/Utils/FMath.hpp +++ b/Src/Utils/FMath.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FMATH_HPP #define FMATH_HPP diff --git a/Src/Utils/FMemStats.cpp b/Src/Utils/FMemStats.cpp index 339e533c832720a118c2cfa535ab11398f2170cb..ff2c4205a3d962ab6e6ee87433d3ccb97c4b8ea0 100644 --- a/Src/Utils/FMemStats.cpp +++ b/Src/Utils/FMemStats.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FMemStats.h" diff --git a/Src/Utils/FMemStats.h b/Src/Utils/FMemStats.h index f4bcb84b6abcfa63eade9578e23c3ca3144a303e..b4dc2c4d9973fd107c5f64f94389009670be5b42 100644 --- a/Src/Utils/FMemStats.h +++ b/Src/Utils/FMemStats.h @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FMEMSTATS_H #define FMEMSTATS_H diff --git a/Src/Utils/FMemUtils.hpp b/Src/Utils/FMemUtils.hpp index 56b804a121b76486ccb126681da05195cf35d797..42dd1da2a7681bbb0249cc0d3e0cb03c0f2afcb4 100644 --- a/Src/Utils/FMemUtils.hpp +++ b/Src/Utils/FMemUtils.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FMEMUTILS_HPP #define FMEMUTILS_HPP @@ -74,6 +69,14 @@ namespace FMemUtils { dest[idx] = source[idx]; } } + + /** Delete all */ + template + void DeleteAll(TypeClass*const array[], const int size){ + for(int idx = 0 ; idx < size ; ++idx){ + delete[] array[idx]; + } + } } #endif // FMEMUTILS_HPP diff --git a/Src/Utils/FMpi.hpp b/Src/Utils/FMpi.hpp index f360a901857e3b6609f7a4038060e80ed1b26a36..aad83ac0bb5c0be927f89addd3774534fa6a003f 100644 --- a/Src/Utils/FMpi.hpp +++ b/Src/Utils/FMpi.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FMPI_HPP #define FMPI_HPP diff --git a/Src/Utils/FNoCopyable.hpp b/Src/Utils/FNoCopyable.hpp index d524f0fbe121fe07d1e7cab39393a64c9e257d46..bb5ca60930275f53516cf74a7849c4825f4e37c1 100644 --- a/Src/Utils/FNoCopyable.hpp +++ b/Src/Utils/FNoCopyable.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FNOCOPYABLE_HPP #define FNOCOPYABLE_HPP diff --git a/Src/Utils/FOmpBarrier.hpp b/Src/Utils/FOmpBarrier.hpp index b46aca20d4093c2c2d9646b4b5460ab2b6f52a20..7b5c4f7f4521ef340b8f983a9e1dffd72aee9e68 100644 --- a/Src/Utils/FOmpBarrier.hpp +++ b/Src/Utils/FOmpBarrier.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FOMPBARRIER_HPP #define FOMPBARRIER_HPP diff --git a/Src/Utils/FParameters.hpp b/Src/Utils/FParameters.hpp index 646b12b2c903533794e962ac818fead76362aa9f..d870d4622922d20fcb9cc4734d0449585862a33a 100644 --- a/Src/Utils/FParameters.hpp +++ b/Src/Utils/FParameters.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FPARAMETERS_H #define FPARAMETERS_H diff --git a/Src/Utils/FQuickSort.hpp b/Src/Utils/FQuickSort.hpp index 1aca9d1a6bb00c96dcd447da1ae372ecdc8630e6..f7c03f506b2e240ccd9dedb70d4f52f966cab8bb 100644 --- a/Src/Utils/FQuickSort.hpp +++ b/Src/Utils/FQuickSort.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FQUICKSORT_HPP #define FQUICKSORT_HPP diff --git a/Src/Utils/FSpherical.hpp b/Src/Utils/FSpherical.hpp index e1f4529190f3f064fa0baa6c9ee55508814d01c0..d6282983205ca12612db9b94acde0dfbbea647da 100644 --- a/Src/Utils/FSpherical.hpp +++ b/Src/Utils/FSpherical.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FSPHERICAL_HPP #define FSPHERICAL_HPP diff --git a/Src/Utils/FTic.cpp b/Src/Utils/FTic.cpp index 38801bd3f167f1baea4652dcac10478dee3279e8..b2e53929732d48508345b47f77ecd360adde4757 100644 --- a/Src/Utils/FTic.cpp +++ b/Src/Utils/FTic.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FTic.hpp" diff --git a/Src/Utils/FTic.hpp b/Src/Utils/FTic.hpp index 5315e9a3f05d85a22e4391468d3e2b1aea746e4b..f32125aba407b51c0630e70ead84037735268348 100644 --- a/Src/Utils/FTic.hpp +++ b/Src/Utils/FTic.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTIC_HPP #define FTIC_HPP diff --git a/Src/Utils/FTrace.cpp b/Src/Utils/FTrace.cpp index 58721ff29681e0e709d52eb39755a28d0cf180bd..2678308ab63978d16f040e9c02f438357a6e2001 100644 --- a/Src/Utils/FTrace.cpp +++ b/Src/Utils/FTrace.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FTrace.hpp" #ifdef SCALFMM_USE_TRACE diff --git a/Src/Utils/FTrace.hpp b/Src/Utils/FTrace.hpp index bd59d5918f063c390a0a0ea93b84f486a75aca20..c43a482bbc8b6739e87e519135439e1ea5ded67e 100644 --- a/Src/Utils/FTrace.hpp +++ b/Src/Utils/FTrace.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef FTRACE_HPP #define FTRACE_HPP diff --git a/Tests/testDebug.cpp b/Tests/testDebug.cpp index a3121d7153e61dbf6dfcbf0ae79e5e543e1833c7..70df84f339ef9c21a4051feaf0a79499f3669ed3 100644 --- a/Tests/testDebug.cpp +++ b/Tests/testDebug.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "../Src/Utils/FDebug.hpp" diff --git a/Tests/testFmbAlgorithm.cpp b/Tests/testFmbAlgorithm.cpp index f3ceeb15e65b8c212e27c2e1c8d21186360256d8..c681a57c9f2f46902701fc00cc5e6bcc588dcfc3 100644 --- a/Tests/testFmbAlgorithm.cpp +++ b/Tests/testFmbAlgorithm.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include @@ -28,8 +23,10 @@ #include "../Src/Core/FFmmAlgorithm.hpp" #include "../Src/Core/FFmmAlgorithmThread.hpp" -#include "../Src/Fmb/FFmbKernels.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" +#include "../Src/Kernels/FSphericalKernel.hpp" +#include "../Src/Kernels/FSphericalCell.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" +#include "../Src/Components/FSimpleLeaf.hpp" #include "../Src/Files/FFmaLoader.hpp" @@ -43,19 +40,19 @@ // Simply create particles and try the kernels int main(int argc, char ** argv){ - typedef FmbParticle ParticleClass; - typedef FmbCell CellClass; - typedef FVector ContainerClass; + typedef FSphericalParticle ParticleClass; + typedef FSphericalCell CellClass; + typedef FVector ContainerClass; typedef FSimpleLeaf LeafClass; typedef FOctree OctreeClass; - typedef FFmbKernels KernelClass; + typedef FSphericalKernel KernelClass; typedef FFmmAlgorithm FmmClass; ///////////////////////What we do///////////////////////////// std::cout << ">> This executable has to be used to test fmb algorithm.\n"; ////////////////////////////////////////////////////////////// - + const int DevP = FParameters::getValue(argc,argv,"-p", 8); const int NbLevels = FParameters::getValue(argc,argv,"-h", 5); const int SizeSubLevels = FParameters::getValue(argc,argv,"-sh", 3); FTic counter; @@ -70,7 +67,7 @@ int main(int argc, char ** argv){ } // ----------------------------------------------------- - + CellClass::Init(DevP); OctreeClass tree(NbLevels, SizeSubLevels, loader.getBoxWidth(), loader.getCenterOfBox()); // ----------------------------------------------------- @@ -95,7 +92,7 @@ int main(int argc, char ** argv){ std::cout << "Working on particles ..." << std::endl; counter.tic(); - KernelClass kernels(NbLevels,loader.getBoxWidth()); + KernelClass kernels(DevP, NbLevels,loader.getBoxWidth()); FmmClass algo(&tree,&kernels); algo.execute(); diff --git a/Tests/testFmbAlgorithmProc.cpp b/Tests/testFmbAlgorithmProc.cpp index 861487d6bd6ff6f397f862f1df9148e47fd6b1b8..7b2d804a75a7daebe53d4c5d25d05b78cecd0055 100644 --- a/Tests/testFmbAlgorithmProc.cpp +++ b/Tests/testFmbAlgorithmProc.cpp @@ -1,30 +1,24 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "../Src/Utils/FTic.hpp" #include "../Src/Utils/FMpi.hpp" -#include "../Src/Utils/FAbstractSendable.hpp" #include "../Src/Utils/FParameters.hpp" #include "../Src/Containers/FOctree.hpp" #include "../Src/Containers/FVector.hpp" -#include "../Src/Fmb/FExtendFmbCell.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" -#include "../Src/Fmb/FFmbKernels.hpp" +#include "../Src/Kernels/FSphericalKernel.hpp" +#include "../Src/Kernels/FSphericalCell.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" #include "../Src/Core/FFmmAlgorithmThreadProc.hpp" #include "../Src/Core/FFmmAlgorithmThread.hpp" @@ -53,11 +47,11 @@ // to test equality between good and potentialy bad solution /////////////////////////////////////////////////////// /** To compare data */ -bool isEqualPole(const FmbSendableCell& me, const FmbSendableCell& other, FReal*const cumul){ +bool isEqualPole(const FSphericalCell& me, const FSphericalCell& other, FReal*const cumul){ //return memcmp(multipole_exp, other.multipole_exp, sizeof(FComplexe)*MultipoleSize) == 0 && // memcmp(local_exp, other.local_exp, sizeof(FComplexe)*MultipoleSize) == 0; *cumul = 0.0; - for(int idx = 0; idx < FExtendFmbCell::MultipoleSize; ++idx){ + for(int idx = 0; idx < FSphericalCell::GetPoleSize(); ++idx){ *cumul += FMath::Abs( me.getMultipole()[idx].getImag() - other.getMultipole()[idx].getImag() ); *cumul += FMath::Abs( me.getMultipole()[idx].getReal() - other.getMultipole()[idx].getReal() ); } @@ -66,11 +60,11 @@ bool isEqualPole(const FmbSendableCell& me, const FmbSendableCell& other, FReal* } /** To compare data */ -bool isEqualLocal(const FmbSendableCell& me, const FmbSendableCell& other, FReal*const cumul){ +bool isEqualLocal(const FSphericalCell& me, const FSphericalCell& other, FReal*const cumul){ //return memcmp(multipole_exp, other.multipole_exp, sizeof(FComplexe)*MultipoleSize) == 0 && // memcmp(local_exp, other.local_exp, sizeof(FComplexe)*MultipoleSize) == 0; *cumul = 0.0; - for(int idx = 0; idx < FExtendFmbCell::MultipoleSize; ++idx){ + for(int idx = 0; idx < FSphericalCell::GetLocalSize(); ++idx){ *cumul += FMath::Abs( me.getLocal()[idx].getImag() - other.getLocal()[idx].getImag() ); *cumul += FMath::Abs( me.getLocal()[idx].getReal() - other.getLocal()[idx].getReal() ); } @@ -103,10 +97,10 @@ void ValidateFMMAlgoProc(OctreeClass* const badTree, } else{ FReal cumul; - if( !octreeIterator.getCurrentCell()->isEqualPole(*octreeIteratorValide.getCurrentCell(),&cumul) ){ + if( !isEqualPole(*octreeIterator.getCurrentCell(),*octreeIteratorValide.getCurrentCell(),&cumul) ){ std::cout << "Pole Data are different." << " Cumul " << cumul << std::endl; } - if( !octreeIterator.getCurrentCell()->isEqualLocal(*octreeIteratorValide.getCurrentCell(),&cumul) ){ + if( !isEqualLocal(*octreeIterator.getCurrentCell(),*octreeIteratorValide.getCurrentCell(),&cumul) ){ std::cout << "Local Data are different." << " Cumul " << cumul << std::endl; } } @@ -175,13 +169,13 @@ void ValidateFMMAlgoProc(OctreeClass* const badTree, // Simply create particles and try the kernels int main(int argc, char ** argv){ - typedef FmbParticle ParticleClass; - typedef FmbSendableCell CellClass; - typedef FVector ContainerClass; + typedef FSphericalParticle ParticleClass; + typedef FSendableSphericalCell CellClass; + typedef FVector ContainerClass; typedef FSimpleLeaf LeafClass; typedef FOctree OctreeClass; - typedef FFmbKernels KernelClass; + typedef FSphericalKernel KernelClass; typedef FFmmAlgorithmThreadProc FmmClass; typedef FFmmAlgorithmThread FmmClassNoProc; @@ -191,6 +185,7 @@ int main(int argc, char ** argv){ FMpi app( argc, argv); + const int DevP = FParameters::getValue(argc,argv,"-p", 8); const int NbLevels = FParameters::getValue(argc,argv,"-h", 5); const int SizeSubLevels = FParameters::getValue(argc,argv,"-sh", 3); FTic counter; @@ -205,7 +200,7 @@ int main(int argc, char ** argv){ } // ----------------------------------------------------- - + CellClass::Init(DevP); OctreeClass tree(NbLevels, SizeSubLevels,loader.getBoxWidth(),loader.getCenterOfBox()); // ----------------------------------------------------- @@ -244,7 +239,7 @@ int main(int argc, char ** argv){ std::cout << "Working on particles ..." << std::endl; counter.tic(); - KernelClass kernels(NbLevels,loader.getBoxWidth()); + KernelClass kernels(DevP, NbLevels,loader.getBoxWidth()); FmmClass algo(app.global(),&tree,&kernels); algo.execute(); diff --git a/Tests/testFmbBlasAlgorithm.cpp b/Tests/testFmbBlasAlgorithm.cpp index 2427e3160d785e085a6f79bb6275981b8e807579..793b16f72408f9f91a31937d945883ba0f75611c 100644 --- a/Tests/testFmbBlasAlgorithm.cpp +++ b/Tests/testFmbBlasAlgorithm.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include @@ -30,11 +25,10 @@ #include "../Src/Components/FSimpleLeaf.hpp" -#include "../Src/Fmb/FFmbKernelsBlockBlas.hpp" -#include "../Src/Fmb/FFmbKernelsBlas.hpp" -#include "../Src/Fmb/FFmbKernels.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" +#include "../Src/Kernels/FSphericalKernel.hpp" +#include "../Src/Kernels/FSphericalBlasKernel.hpp" +#include "../Src/Kernels/FSphericalCell.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" #include "../Src/Files/FFmaScanfLoader.hpp" @@ -47,19 +41,19 @@ // Simply create particles and try the kernels int main(int argc, char ** argv){ - typedef FmbParticle ParticleClass; - typedef FmbCell CellClass; - typedef FVector ContainerClass; + typedef FSphericalParticle ParticleClass; + typedef FSphericalCell CellClass; + typedef FVector ContainerClass; typedef FSimpleLeaf LeafClass; typedef FOctree OctreeClass; - typedef FFmbKernelsBlockBlas KernelClass; + typedef FSphericalBlasKernel KernelClass; typedef FFmmAlgorithm FmmClass; ///////////////////////What we do///////////////////////////// std::cout << ">> This executable has to be used to test fmb algorithm.\n"; ////////////////////////////////////////////////////////////// - + const int DevP = FParameters::getValue(argc,argv,"-p", 8); const int NbLevels = FParameters::getValue(argc,argv,"-h", 5); const int SizeSubLevels = FParameters::getValue(argc,argv,"-sh", 3); FTic counter; @@ -74,7 +68,7 @@ int main(int argc, char ** argv){ } // ----------------------------------------------------- - + CellClass::Init(DevP); OctreeClass tree(NbLevels, SizeSubLevels,loader.getBoxWidth(),loader.getCenterOfBox()); // ----------------------------------------------------- @@ -99,7 +93,7 @@ int main(int argc, char ** argv){ std::cout << "Working on particles ..." << std::endl; counter.tic(); - KernelClass kernels(NbLevels,loader.getBoxWidth()); + KernelClass kernels(DevP, NbLevels, loader.getBoxWidth()); FmmClass algo(&tree,&kernels); algo.execute(); diff --git a/Tests/testFmbEwalAlgorithm.cpp b/Tests/testFmbEwalAlgorithm.cpp index ef558d327ff8c130a4ca68695fc0ee291656521c..4c1352b40d3f5070c475160324c4586b1af926ae 100644 --- a/Tests/testFmbEwalAlgorithm.cpp +++ b/Tests/testFmbEwalAlgorithm.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include @@ -27,16 +22,17 @@ #include "../Src/Core/FFmmAlgorithmPeriodic.hpp" -#include "../Src/Kernels/FSphericalCell.hpp" #include "../Src/Kernels/FSphericalKernel.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" +#include "../Src/Kernels/FSphericalCell.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" #include "../Src/Files/FEwalLoader.hpp" +#include "../Src/Components/FSimpleLeaf.hpp" /** Ewal particle is used in the gadget program * here we try to make the same simulation */ -class EwalParticle : public FmbParticle { +class EwalParticle : public FSphericalParticle { public: // Type of particle enum Type{ @@ -75,7 +71,7 @@ public: // Simply create particles and try the kernels int main(int argc, char ** argv){ typedef EwalParticle ParticleClass; - typedef FSphericalCell CellClass; + typedef FSphericalCell CellClass; typedef FVector ContainerClass; typedef FSimpleLeaf LeafClass; diff --git a/Tests/testFmbGalaxyCsv.cpp b/Tests/testFmbGalaxyCsv.cpp index 8b9b66a7fe9fdc7a194f2940147becd5756abba0..284835ee905b0d39ca314bf2e00f950825290c8f 100644 --- a/Tests/testFmbGalaxyCsv.cpp +++ b/Tests/testFmbGalaxyCsv.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include @@ -30,7 +25,7 @@ #include "../Src/Kernels/FSphericalKernel.hpp" #include "../Src/Kernels/FSphericalCell.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" #include "../Src/Extensions/FExtendVelocity.hpp" @@ -38,8 +33,9 @@ #include "../Src/Files/FFmaLoader.hpp" #include "../Src/Arranger/FOctreeArranger.hpp" +#include "../Src/Components/FSimpleLeaf.hpp" -class FmbVeloParticle : public FmbParticle, public FExtendVelocity { +class FmmVeloParticle : public FSphericalParticle, public FExtendVelocity { }; template @@ -72,8 +68,8 @@ public: // Simply create particles and try the kernels int main(int argc, char ** argv){ - typedef FmbVeloParticle ParticleClass; - typedef FSphericalCell CellClass; + typedef FmmVeloParticle ParticleClass; + typedef FSphericalCell CellClass; typedef FVector ContainerClass; typedef FSimpleLeaf LeafClass; diff --git a/Tests/testFmbRotation.cpp b/Tests/testFmbRotation.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0a6ac6d7616f2100b7c8f0128a2823324f1cdd92 --- /dev/null +++ b/Tests/testFmbRotation.cpp @@ -0,0 +1,127 @@ +// =================================================================================== +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. +// =================================================================================== + +#include + +#include +#include + +#include "../Src/Utils/FTic.hpp" +#include "../Src/Utils/FParameters.hpp" + +#include "../Src/Containers/FOctree.hpp" +#include "../Src/Containers/FVector.hpp" + +#include "../Src/Core/FFmmAlgorithm.hpp" +#include "../Src/Core/FFmmAlgorithmThread.hpp" + +#include "../Src/Components/FSimpleLeaf.hpp" + +#include "../Src/Kernels/FSphericalRotationKernel.hpp" +#include "../Src/Kernels/FSphericalCell.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" + +#include "../Src/Files/FFmaScanfLoader.hpp" + +/** This program show an example of use of + * the fmm basic algo + * it also check that eachh particles is little or longer + * related that each other + */ + + +// Simply create particles and try the kernels +int main(int argc, char ** argv){ + typedef FSphericalParticle ParticleClass; + typedef FSphericalCell CellClass; + typedef FVector ContainerClass; + + typedef FSimpleLeaf LeafClass; + typedef FOctree OctreeClass; + typedef FSphericalRotationKernel KernelClass; + + typedef FFmmAlgorithm FmmClass; + ///////////////////////What we do///////////////////////////// + std::cout << ">> This executable has to be used to test fmb algorithm.\n"; + ////////////////////////////////////////////////////////////// + const int DevP = FParameters::getValue(argc,argv,"-p", 8); + const int NbLevels = FParameters::getValue(argc,argv,"-h", 5); + const int SizeSubLevels = FParameters::getValue(argc,argv,"-sh", 3); + FTic counter; + + const char* const filename = FParameters::getStr(argc,argv,"-f", "../Data/test20k.fma"); + std::cout << "Opening : " << filename << "\n"; + + FFmaScanfLoader loader(filename); + if(!loader.isOpen()){ + std::cout << "Loader Error, " << filename << " is missing\n"; + return 1; + } + + // ----------------------------------------------------- + CellClass::Init(DevP); + OctreeClass tree(NbLevels, SizeSubLevels,loader.getBoxWidth(),loader.getCenterOfBox()); + + // ----------------------------------------------------- + + std::cout << "Creating & Inserting " << loader.getNumberOfParticles() << " particles ..." << std::endl; + std::cout << "\tHeight : " << NbLevels << " \t sub-height : " << SizeSubLevels << std::endl; + counter.tic(); + + { + ParticleClass particleToFill; + for(int idxPart = 0 ; idxPart < loader.getNumberOfParticles() ; ++idxPart){ + loader.fillParticle(particleToFill); + tree.insert(particleToFill); + } + } + + counter.tac(); + std::cout << "Done " << "(@Creating and Inserting Particles = " << counter.elapsed() << "s)." << std::endl; + + // ----------------------------------------------------- + + std::cout << "Working on particles ..." << std::endl; + counter.tic(); + + KernelClass kernels(DevP, NbLevels, loader.getBoxWidth()); + + FmmClass algo(&tree,&kernels); + algo.execute(); + + counter.tac(); + std::cout << "Done " << "(@Algorithm = " << counter.elapsed() << "s)." << std::endl; + + { // get sum forces&potential + FReal potential = 0; + F3DPosition forces; + typename OctreeClass::Iterator octreeIterator(&tree); + octreeIterator.gotoBottomLeft(); + do{ + typename ContainerClass::ConstBasicIterator iter(*octreeIterator.getCurrentListTargets()); + while( iter.hasNotFinished() ){ + potential += iter.data().getPotential() * iter.data().getPhysicalValue(); + forces += iter.data().getForces(); + + iter.gotoNext(); + } + } while(octreeIterator.moveRight()); + + std::cout << "Foces Sum x = " << forces.getX() << " y = " << forces.getY() << " z = " << forces.getZ() << std::endl; + std::cout << "Potential = " << potential << std::endl; + } + + return 0; +} + + + + diff --git a/Tests/testFmbTsmAlgorithm.cpp b/Tests/testFmbTsmAlgorithm.cpp index e4f0cdd6976d1066c7baf388bf5d08aca7ff00eb..4cba5ca4a9ccac98079aa84416c83ef175f1731c 100644 --- a/Tests/testFmbTsmAlgorithm.cpp +++ b/Tests/testFmbTsmAlgorithm.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include @@ -29,8 +24,9 @@ #include "../Src/Core/FFmmAlgorithmTsm.hpp" -#include "../Src/Fmb/FFmbKernels.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" +#include "../Src/Kernels/FSphericalKernel.hpp" +#include "../Src/Kernels/FSphericalCell.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" #include "../Src/Files/FFmaTsmLoader.hpp" @@ -43,19 +39,19 @@ // Simply create particles and try the kernels int main(int argc, char ** argv){ - typedef FmbTypedParticle ParticleClass; - typedef FmbTypedCell CellClass; - typedef FVector ContainerClass; + typedef FTypedSphericalParticle ParticleClass; + typedef FTypedSphericalCell CellClass; + typedef FVector ContainerClass; typedef FTypedLeaf LeafClass; typedef FOctree OctreeClass; - typedef FFmbKernels KernelClass; + typedef FSphericalKernel KernelClass; typedef FFmmAlgorithmTsm FmmClass; ///////////////////////What we do///////////////////////////// std::cout << ">> This executable has to be used to test Fmb on a Tsm system.\n"; ////////////////////////////////////////////////////////////// - + const int DevP = FParameters::getValue(argc,argv,"-p", 8); const int NbLevels = FParameters::getValue(argc,argv,"-h", 5); const int SizeSubLevels = FParameters::getValue(argc,argv,"-sh", 3); FTic counter; @@ -70,7 +66,7 @@ int main(int argc, char ** argv){ } // ----------------------------------------------------- - + CellClass::Init(DevP); OctreeClass tree(NbLevels, SizeSubLevels,loader.getBoxWidth(),loader.getCenterOfBox()); // ----------------------------------------------------- @@ -95,7 +91,7 @@ int main(int argc, char ** argv){ std::cout << "Working on particles ..." << std::endl; counter.tic(); - KernelClass kernels(NbLevels,loader.getBoxWidth()); + KernelClass kernels(DevP, NbLevels, loader.getBoxWidth()); FmmClass algo(&tree,&kernels); algo.execute(); diff --git a/Tests/testFmbTsmNoTsm.cpp b/Tests/testFmbTsmNoTsm.cpp index b30b0d2d0907e750064f84c89ea751316ace1574..01f43ad7050b8da962ef9fb19d96113a3573877a 100644 --- a/Tests/testFmbTsmNoTsm.cpp +++ b/Tests/testFmbTsmNoTsm.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include @@ -25,9 +20,9 @@ #include "../Src/Containers/FOctree.hpp" #include "../Src/Containers/FVector.hpp" -#include "../Src/Fmb/FExtendFmbCell.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" -#include "../Src/Fmb/FFmbKernels.hpp" +#include "../Src/Kernels/FSphericalKernel.hpp" +#include "../Src/Kernels/FSphericalCell.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" #include "../Src/Core/FFmmAlgorithm.hpp" #include "../Src/Core/FFmmAlgorithmTsm.hpp" @@ -47,23 +42,23 @@ // Simply create particles and try the kernels int main(int argc, char ** argv){ - typedef FmbParticle ParticleClass; - typedef FmbCell CellClass; - typedef FVector ContainerClass; + typedef FSphericalParticle ParticleClass; + typedef FSphericalCell CellClass; + typedef FVector ContainerClass; typedef FSimpleLeaf LeafClass; typedef FOctree OctreeClass; - typedef FFmbKernels KernelClass; + typedef FSphericalKernel KernelClass; typedef FFmmAlgorithmThread FmmClass; - typedef FmbTypedParticle ParticleClassTyped; - typedef FmbTypedCell CellClassTyped; + typedef FTypedSphericalParticle ParticleClassTyped; + typedef FTypedSphericalCell CellClassTyped; typedef FVector ContainerClassTyped; typedef FTypedLeaf LeafClassTyped; typedef FOctree OctreeClassTyped; - typedef FFmbKernels KernelClassTyped; + typedef FSphericalKernel KernelClassTyped; typedef FFmmAlgorithmThreadTsm FmmClassTyped; @@ -71,7 +66,7 @@ int main(int argc, char ** argv){ std::cout << ">> This executable has to be used to test Fmb on a Tsm system.\n"; std::cout << ">> It compares the results between Tms and no Tms (except P2P & L2P).\n"; ////////////////////////////////////////////////////////////// - + const int DevP = FParameters::getValue(argc,argv,"-p", 8); const int NbLevels = FParameters::getValue(argc,argv,"-h", 5); const int SizeSubLevels = FParameters::getValue(argc,argv,"-sh", 3); FTic counter; @@ -82,6 +77,8 @@ int main(int argc, char ** argv){ // ----------------------------------------------------- + CellClass::Init(DevP); + OctreeClass tree(NbLevels, SizeSubLevels,BoxWidth,CenterOfBox); OctreeClassTyped treeTyped(NbLevels, SizeSubLevels,BoxWidth,CenterOfBox); @@ -123,8 +120,8 @@ int main(int argc, char ** argv){ std::cout << "Working on particles ..." << std::endl; counter.tic(); - KernelClass kernels(NbLevels,BoxWidth); - KernelClassTyped kernelsTyped(NbLevels,BoxWidth); + KernelClass kernels(DevP, NbLevels, BoxWidth); + KernelClassTyped kernelsTyped(DevP, NbLevels, BoxWidth); FmmClass algo(&tree,&kernels); FmmClassTyped algoTyped(&treeTyped,&kernelsTyped); @@ -153,7 +150,7 @@ int main(int argc, char ** argv){ do{ bool poleDiff = false; bool localDiff = false; - for(int idxValues = 0 ; idxValues < FExtendFmbCell::MultipoleSize && !(poleDiff && localDiff); ++idxValues){ + for(int idxValues = 0 ; idxValues < FSphericalCell::GetPoleSize() && !(poleDiff && localDiff); ++idxValues){ const FComplexe pole = octreeIterator.getCurrentCell()->getMultipole()[idxValues]; const FComplexe poleTyped = octreeIteratorTyped.getCurrentCell()->getMultipole()[idxValues]; if(!FMath::LookEqual(pole.getImag(),poleTyped.getImag()) || !FMath::LookEqual(pole.getReal(),poleTyped.getReal())){ @@ -161,6 +158,8 @@ int main(int argc, char ** argv){ printf("Pole diff imag( %.15e , %.15e ) real( %.15e , %.15e)\n", pole.getImag(),poleTyped.getImag(),pole.getReal(),poleTyped.getReal()); } + } + for(int idxValues = 0 ; idxValues < FSphericalCell::GetPoleSize() && !(poleDiff && localDiff); ++idxValues){ const FComplexe local = octreeIterator.getCurrentCell()->getLocal()[idxValues]; const FComplexe localTyped = octreeIteratorTyped.getCurrentCell()->getLocal()[idxValues]; if(!FMath::LookEqual(local.getImag(),localTyped.getImag()) || !FMath::LookEqual(local.getReal(),localTyped.getReal())){ diff --git a/Tests/testFmmAlgorithm.cpp b/Tests/testFmmAlgorithm.cpp index 64fbb48ca57976114bfaaaffa2f9f72664df21e6..84ea8dea5f2d0df0f3ee7cb8b6f4fe3c0dbd7e23 100644 --- a/Tests/testFmmAlgorithm.cpp +++ b/Tests/testFmmAlgorithm.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testFmmAlgorithmPeriodic.cpp b/Tests/testFmmAlgorithmPeriodic.cpp index 298ebf568124566e5e91af913814dc5ee7b6e5bf..c43c71aab2fa3687ab65885221ed2a4b93a604dd 100644 --- a/Tests/testFmmAlgorithmPeriodic.cpp +++ b/Tests/testFmmAlgorithmPeriodic.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== diff --git a/Tests/testFmmAlgorithmProc.cpp b/Tests/testFmmAlgorithmProc.cpp index 9e885ff76c2cdc16706e9b5d538e7cd93f357784..90472cd0f0b9fcb9d514dd2b33d1965dc3cc13b4 100644 --- a/Tests/testFmmAlgorithmProc.cpp +++ b/Tests/testFmmAlgorithmProc.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "../Src/Utils/FMpi.hpp" diff --git a/Tests/testFmmAlgorithmProcPeriodic.cpp b/Tests/testFmmAlgorithmProcPeriodic.cpp index a581f3785a499cb18c9e7ed2500bedd172aa24bb..880f88afa7ffff51a8fc0f94b7e23a765c9c9ff5 100644 --- a/Tests/testFmmAlgorithmProcPeriodic.cpp +++ b/Tests/testFmmAlgorithmProcPeriodic.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== diff --git a/Tests/testFmmAlgorithmTsm.cpp b/Tests/testFmmAlgorithmTsm.cpp index 31d2d84505c546b2d6633041ba1ef36e7fe8196e..ab4baccb73491ece4577718ba9bb1c778a405acc 100644 --- a/Tests/testFmmAlgorithmTsm.cpp +++ b/Tests/testFmmAlgorithmTsm.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testFmmDemonstration.cpp b/Tests/testFmmDemonstration.cpp index ed79da83a6ed7fc1327b1eeb850b7711c98dad2a..40f5cd117c48c32b4adee37717b51be83195cc1b 100644 --- a/Tests/testFmmDemonstration.cpp +++ b/Tests/testFmmDemonstration.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testLoader.cpp b/Tests/testLoader.cpp index 24a4e3a003f33df7611fdfe598c28f3666f183ac..8fb4adac2aca691dde7a9c92a4a4c632d317b2e2 100644 --- a/Tests/testLoader.cpp +++ b/Tests/testLoader.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testLoaderCreate.cpp b/Tests/testLoaderCreate.cpp index e776c7e92ecdd0c3cbeaf3a80379cf4807b00bef..168c1f2d6a8e026de3b5293acfed5396c5f72a1b 100644 --- a/Tests/testLoaderCreate.cpp +++ b/Tests/testLoaderCreate.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testLoaderFMA.cpp b/Tests/testLoaderFMA.cpp index e417a6c6dcbd792e750557f3e142987d732bdb37..d02f7b5782465f5b76549a1813d1867aa7da4b2d 100644 --- a/Tests/testLoaderFMA.cpp +++ b/Tests/testLoaderFMA.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testLoaderFMABinCreate.cpp b/Tests/testLoaderFMABinCreate.cpp index 7c043fa0a9d2d69270c950613268738cbce23f26..2b6ba72db8c58522a5671c65303673d33a912642 100644 --- a/Tests/testLoaderFMABinCreate.cpp +++ b/Tests/testLoaderFMABinCreate.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testLoaderFMACreate.cpp b/Tests/testLoaderFMACreate.cpp index 5e9b8dfaf1f0fc20676d0cea4e10a2400ae9b428..ac4a1eae8a3639407d61ddf635e8b4e9f769c62e 100644 --- a/Tests/testLoaderFMACreate.cpp +++ b/Tests/testLoaderFMACreate.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testLoaderFMACreateSphere.cpp b/Tests/testLoaderFMACreateSphere.cpp index 06ec55c74d036058c20f6f574dddfae621fda84a..a67aa7a653dfed62ef828f94ba6c7e87aba0893d 100644 --- a/Tests/testLoaderFMACreateSphere.cpp +++ b/Tests/testLoaderFMACreateSphere.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testLoaderFMATsm.cpp b/Tests/testLoaderFMATsm.cpp index bf4ab675ea594e87d82cb820a380570412806701..599ee4186f75ab08271b1c1752f6d3862a1d1e55 100644 --- a/Tests/testLoaderFMATsm.cpp +++ b/Tests/testLoaderFMATsm.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testLoaderFMATsmCreate.cpp b/Tests/testLoaderFMATsmCreate.cpp index b9f2e3eb593144e2bc47ac96d93304cd200665d9..5e51c92927a437e3e1ecddabcf46c1d77f140aa4 100644 --- a/Tests/testLoaderFMATsmCreate.cpp +++ b/Tests/testLoaderFMATsmCreate.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testMemStats.cpp b/Tests/testMemStats.cpp index bf2e9162271224057b92c3ee6a12c6638bf1ebaa..f58a4a7a28b9ac4d167024bcdd6c4155d10db390 100644 --- a/Tests/testMemStats.cpp +++ b/Tests/testMemStats.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testMortonIndex.cpp b/Tests/testMortonIndex.cpp index 84b5f055d6dc4369f54fc9df0ec1ac78a6b562b3..8f78f71637dc12728a5160a3dad751bbd32204ab 100644 --- a/Tests/testMortonIndex.cpp +++ b/Tests/testMortonIndex.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testOctree.cpp b/Tests/testOctree.cpp index f276a8be07fac7c243c3dec949cf5c3eade67f56..139c093e60cf00e85bae8144c045faf407e12b83 100644 --- a/Tests/testOctree.cpp +++ b/Tests/testOctree.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testOctreeIter.cpp b/Tests/testOctreeIter.cpp index 7d7c8173d8afdf1992cb2aadfa708bd94e442e39..50d5d918fb4f58743397b1b90ebbb59f5f4675bf 100644 --- a/Tests/testOctreeIter.cpp +++ b/Tests/testOctreeIter.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testOctreePrintMorton.cpp b/Tests/testOctreePrintMorton.cpp index 25ee820334f503e169a527dcfb1fb50ed487f19b..eca795ee1684cc540d76fca84d249836c01a9f82 100644 --- a/Tests/testOctreePrintMorton.cpp +++ b/Tests/testOctreePrintMorton.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testOctreeRearrange.cpp b/Tests/testOctreeRearrange.cpp index a6a805ffe5958af6d62a66fcc6e17f1fa461fafa..b3a5bb90b6a6e49ba2cf19e284ee879c8b2af80c 100644 --- a/Tests/testOctreeRearrange.cpp +++ b/Tests/testOctreeRearrange.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testOctreeRearrangeProc.cpp b/Tests/testOctreeRearrangeProc.cpp index 50dc143664306c54005826d70c3bbc2c3de6513a..9011a9221f6b8b66531d244dc9a425104797bf73 100644 --- a/Tests/testOctreeRearrangeProc.cpp +++ b/Tests/testOctreeRearrangeProc.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testStatsTree.cpp b/Tests/testStatsTree.cpp index 8b110108146c355c3624c88b48e3da94074beead..bb199b8b3038ad6269493baa231554830dfea1ce 100644 --- a/Tests/testStatsTree.cpp +++ b/Tests/testStatsTree.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/Tests/testTic.cpp b/Tests/testTic.cpp index 27e165b909d9f4cdf8abcfa1d5a4a32b04e90ca0..525892311c5302058a9a7f03323078abf6fe9704 100644 --- a/Tests/testTic.cpp +++ b/Tests/testTic.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include #include "../Src/Utils/FTic.hpp" diff --git a/Tests/testTreeIO.cpp b/Tests/testTreeIO.cpp index 27012041f53c031dd2b3eca8eaac9d69607cfb15..5303f5c79fb5c9266cc65d54ed779018c6dfcba8 100644 --- a/Tests/testTreeIO.cpp +++ b/Tests/testTreeIO.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include diff --git a/UTests/FUTester.hpp b/UTests/FUTester.hpp index a4ee9adf38dd3dd13a6fc16c6de31dfdf1e6edd3..4424e9aca039dea8cb0d594755c1e185281d7ac0 100644 --- a/UTests/FUTester.hpp +++ b/UTests/FUTester.hpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #ifndef UTESTER_HPP #define UTESTER_HPP diff --git a/UTests/utestBoolArray.cpp b/UTests/utestBoolArray.cpp index 49be6dc9397c01c0477c00a2d32f176ca8bde010..f7b2e2f07b135351548ed1f1106b7957beb122ca 100644 --- a/UTests/utestBoolArray.cpp +++ b/UTests/utestBoolArray.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FUTester.hpp" diff --git a/UTests/utestFmb.cpp b/UTests/utestFmb.cpp index 22e09aabb2056fd3a4abd5457016d29c14643cda..11a1ee18d81823fa8481566af0ba36a239744213 100644 --- a/UTests/utestFmb.cpp +++ b/UTests/utestFmb.cpp @@ -1,26 +1,20 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "../Src/Containers/FOctree.hpp" #include "../Src/Containers/FVector.hpp" #include "../Src/Kernels/FSphericalCell.hpp" #include "../Src/Kernels/FSphericalKernel.hpp" - -#include "../Src/Fmb/FFmbKernels.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" +#include "../Src/Components/FSimpleLeaf.hpp" #include "../Src/Files/FFmaBinLoader.hpp" #include "../Src/Files/FTreeIO.hpp" @@ -35,7 +29,7 @@ */ /** The result of a previous simulation has been saved and will be oponed */ -class FmbParticleSerial : public FmbParticle, public FTreeIO::FAbstractSerial { +class ParticleSerial : public FSphericalParticle, public FTreeIO::FAbstractSerial { public: void write(std::ofstream*const stream) const{ save(stream, getPosition().getX()); @@ -68,21 +62,20 @@ public: class ComputeCellSerial : public FSphericalCell, public FTreeIO::FAbstractSerial { public: void write(std::ofstream*const stream) const{ - saveArray(stream, FSphericalCell::getMultipole(), FSphericalCell::ExpP); - saveArray(stream, FSphericalCell::getLocal(), FSphericalCell::ExpP); + saveArray(stream, FSphericalCell::getMultipole(), FSphericalCell::GetPoleSize()); + saveArray(stream, FSphericalCell::getLocal(), FSphericalCell::GetLocalSize()); } void read(std::ifstream*const stream){ - restoreArray(stream, FSphericalCell::getMultipole(), FSphericalCell::ExpP); - restoreArray(stream, FSphericalCell::getLocal(), FSphericalCell::ExpP); + restoreArray(stream, FSphericalCell::getMultipole(), FSphericalCell::GetPoleSize()); + restoreArray(stream, FSphericalCell::getLocal(), FSphericalCell::GetLocalSize()); } }; -typedef FmbParticleSerial ParticleClass; +typedef ParticleSerial ParticleClass; typedef ComputeCellSerial CellClass; typedef FVector ContainerClass; -//typedef FFmbKernels KernelClass; typedef FSphericalKernel KernelClass; typedef FSimpleLeaf LeafClass; @@ -193,10 +186,10 @@ class TestFmb : public FUTester { } assert( memcmp(testOctreeIterator.getCurrentCell()->getLocal(), - goodOctreeIterator.getCurrentCell()->getLocal(), CellClass::GetExp() * sizeof(FComplexe)) == 0); + goodOctreeIterator.getCurrentCell()->getLocal(), CellClass::GetLocalSize() * sizeof(FComplexe)) == 0); assert( memcmp(testOctreeIterator.getCurrentCell()->getMultipole(), - goodOctreeIterator.getCurrentCell()->getMultipole(),CellClass::GetExp() * sizeof(FComplexe)) == 0); + goodOctreeIterator.getCurrentCell()->getMultipole(),CellClass::GetPoleSize() * sizeof(FComplexe)) == 0); if(!testOctreeIterator.moveRight()){ if(goodOctreeIterator.moveRight()){ diff --git a/UTests/utestFmbDirect.cpp b/UTests/utestFmbDirect.cpp index ee4af0e2086dcdf674190198c860bdf0223cb59e..2684f05a2cdb7cd0799001de0e7c0e99d6cf12e6 100644 --- a/UTests/utestFmbDirect.cpp +++ b/UTests/utestFmbDirect.cpp @@ -1,27 +1,22 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "../Src/Containers/FOctree.hpp" #include "../Src/Containers/FVector.hpp" -#include "../Src/Fmb/FFmbKernels.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" - #include "../Src/Kernels/FSphericalCell.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" +#include "../Src/Components/FSimpleLeaf.hpp" #include "../Src/Kernels/FSphericalKernel.hpp" +#include "../Src/Kernels/FSphericalBlasKernel.hpp" #include "../Src/Files/FFmaBinLoader.hpp" #include "../Src/Files/FTreeIO.hpp" @@ -36,7 +31,7 @@ */ /** We need to know the position of the particle in the array */ -class IndexedParticle : public FmbParticle { +class IndexedParticle : public FSphericalParticle { int index; public: IndexedParticle(): index(-1){} @@ -52,12 +47,11 @@ public: class TestFmbDirect : public FUTester { typedef IndexedParticle ParticleClass; - //typedef FmbCell CellClass; typedef FSphericalCell CellClass; typedef FVector ContainerClass; - //typedef FFmbKernels KernelClass; - typedef FSphericalKernel KernelClass; + typedef FSphericalBlasKernel KernelClass; + //typedef FSphericalKernel KernelClass; typedef FSimpleLeaf LeafClass; typedef FOctree OctreeClass; diff --git a/UTests/utestFmbDirectPeriodic.cpp b/UTests/utestFmbDirectPeriodic.cpp index 447ee7e78d08d67152ef3be8f427155ad429ff88..927489efe75edcb48f331e064ecdce5d9cafbc1d 100644 --- a/UTests/utestFmbDirectPeriodic.cpp +++ b/UTests/utestFmbDirectPeriodic.cpp @@ -1,27 +1,21 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "../Src/Containers/FOctree.hpp" #include "../Src/Containers/FVector.hpp" -#include "../Src/Fmb/FFmbComponents.hpp" - #include "../Src/Kernels/FSphericalCell.hpp" - #include "../Src/Kernels/FSphericalKernel.hpp" +#include "../Src/Kernels/FSphericalParticle.hpp" +#include "../Src/Components/FSimpleLeaf.hpp" #include "../Src/Core/FFmmAlgorithmPeriodic.hpp" #include "FUTester.hpp" @@ -33,7 +27,7 @@ /* In this test we compare the fmm results and the direct results. */ -class IndexedParticle : public FmbParticle { +class IndexedParticle : public FSphericalParticle { int index; public: IndexedParticle(): index(-1){} @@ -135,16 +129,16 @@ class TestFmbDirectPeriodic : public FUTester { } Print("Direct..."); - for(int idxTarget = 0 ; idxTarget < directNbPart ; idxTarget += 8){ + /*for(int idxTarget = 0 ; idxTarget < directNbPart ; idxTarget += 8){ for(int idxOther = idxTarget + 8 ; idxOther < directNbPart ; idxOther += 8){ kernels.directInteractionMutual(&particles[idxTarget], &particles[idxOther]); } - }//todo exchange - /*for(int idxTarget = 0 ; idxTarget < directNbPart ; ++idxTarget){ + }//todo exchange*/ + for(int idxTarget = 0 ; idxTarget < directNbPart ; ++idxTarget){ for(int idxOther = idxTarget + 1 ; idxOther < directNbPart ; ++idxOther){ kernels.directInteractionMutual(&particles[idxTarget], &particles[idxOther]); } - }*/ + } // Compare Print("Compute Diff..."); diff --git a/UTests/utestList.cpp b/UTests/utestList.cpp index e89f4643b6790849bd6cb13a6171724317f043fd..304320e3a2cd0a1e5b350868f36bf8c6077613cd 100644 --- a/UTests/utestList.cpp +++ b/UTests/utestList.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FUTester.hpp" diff --git a/UTests/utestMorton.cpp b/UTests/utestMorton.cpp index 0df8e656870b7516e552cb89e350e87981aa3d07..b945d0ca1e0dff1a79f546caf4a43340e41a2f6a 100644 --- a/UTests/utestMorton.cpp +++ b/UTests/utestMorton.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FUTester.hpp" diff --git a/UTests/utestOctree.cpp b/UTests/utestOctree.cpp index c7bd3736c82fc7e933d642733922dd699bb70c33..3f644f874deb70004cfbb8894f988a24d8cd04aa 100644 --- a/UTests/utestOctree.cpp +++ b/UTests/utestOctree.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FUTester.hpp" diff --git a/UTests/utestParameters.cpp b/UTests/utestParameters.cpp index 5998222346d1161f95c97ec91cda21735cbeb0e6..5fde70a90a6e6347605ff0afca6fd6df03207ec6 100644 --- a/UTests/utestParameters.cpp +++ b/UTests/utestParameters.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FUTester.hpp" diff --git a/UTests/utestQuicksort.cpp b/UTests/utestQuicksort.cpp index 6184139d3478ea065dda7437a26dee7ac6026303..a05ca002fb4cc8d69f37fb5aa41321726e964632 100644 --- a/UTests/utestQuicksort.cpp +++ b/UTests/utestQuicksort.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FUTester.hpp" #include "../Src/Utils/FQuickSort.hpp" diff --git a/UTests/utestTest.cpp b/UTests/utestTest.cpp index 843022430d45e1b097aebf7aded2d32192d8b2d5..40f7d9061327a61622d1d8a693e6b748ad911b3f 100644 --- a/UTests/utestTest.cpp +++ b/UTests/utestTest.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FUTester.hpp" diff --git a/UTests/utestVector.cpp b/UTests/utestVector.cpp index c5372d745dc6a36c297917dff39bea6d15543ddf..4d6d38877d11b527d14b6ef957dba317ee43ad84 100644 --- a/UTests/utestVector.cpp +++ b/UTests/utestVector.cpp @@ -1,17 +1,12 @@ // =================================================================================== -// Ce LOGICIEL "ScalFmm" est couvert par le copyright Inria 20xx-2012. -// Inria détient tous les droits de propriété sur le LOGICIEL, et souhaite que -// la communauté scientifique l'utilise afin de le tester et de l'évaluer. -// Inria donne gracieusement le droit d'utiliser ce LOGICIEL. Toute utilisation -// dans un but lucratif ou à des fins commerciales est interdite sauf autorisation -// expresse et préalable d'Inria. -// Toute utilisation hors des limites précisées ci-dessus et réalisée sans l'accord -// expresse préalable d'Inria constituerait donc le délit de contrefaçon. -// Le LOGICIEL étant un produit en cours de développement, Inria ne saurait assurer -// aucune responsabilité et notamment en aucune manière et en aucun cas, être tenu -// de répondre d'éventuels dommages directs ou indirects subits par l'utilisateur. -// Tout utilisateur du LOGICIEL s'engage à communiquer à Inria ses remarques -// relatives à l'usage du LOGICIEL +// Logiciel initial: ScalFmm Version 0.5 +// Co-auteurs : Olivier Coulaud, Bérenger Bramas. +// Propriétaires : INRIA. +// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire. +// Initial software: ScalFmm Version 0.5 +// Co-authors: Olivier Coulaud, Bérenger Bramas. +// Owners: INRIA. +// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license. // =================================================================================== #include "FUTester.hpp"