Create LICENSE

Previously wrong License type was applied

CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -37,7 +37,7 @@ ENDIF()
 
 # Versioning
 # ===========
-SALOME_SETUP_VERSION(9.9.0 DEVELOPMENT)
+SALOME_SETUP_VERSION(9.12.0)
 MESSAGE(STATUS "Building ${PROJECT_NAME_UC} ${${PROJECT_NAME_UC}_VERSION} from \"${${PROJECT_NAME_UC}_GIT_SHA1}\"")
 
 # Find KERNEL

COPYING

@@ -1,340 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year  name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
-Public License instead of this License.

LICENSE

@@ -0,0 +1,504 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+    USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random
+  Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

NETGENPLUGIN_version.h.in

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

SalomeNETGENPLUGINConfig.cmake.in

@@ -5,7 +5,7 @@
 #
 
 ###############################################################
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

adm_local/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

adm_local/unix/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public

adm_local/unix/config_files/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

adm_local/unix/config_files/check_NETGEN.m4

@@ -1,4 +1,4 @@
-dnl Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+dnl Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 dnl
 dnl Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 dnl CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

adm_local/unix/config_files/check_NETGENPLUGIN.m4

@@ -1,4 +1,4 @@
-dnl Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+dnl Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 dnl
 dnl Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 dnl CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

bin/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public

doc/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

doc/salome/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

doc/salome/examples/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2013-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2013-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public

doc/salome/gui/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

doc/salome/gui/NETGENPLUGIN/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public

doc/salome/gui/NETGENPLUGIN/static/footer.html

@@ -4,7 +4,7 @@
   <ul>
     $navpath
     <li class="footer">
-      Copyright &copy; 2007-2022  CEA/DEN, EDF R&amp;D, OPEN CASCADE<br>
+      Copyright &copy; 2007-2024  CEA, EDF, OPEN CASCADE<br>
       Copyright &copy; 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&amp;D, LEG, PRINCIPIA R&amp;D, BUREAU VERITAS<br>
     </li>
   </ul>

idl/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public

idl/NETGENPlugin_Algorithm.idl

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -44,6 +44,13 @@ module NETGENPlugin
   {
   };
 
+  /*!
+   * NETGENPlugin_NETGEN_3D: interface of "Remote Tetrahedron (Netgen)" algorithm
+   */
+  interface NETGENPlugin_NETGEN_3D_Remote : NETGENPlugin::NETGENPlugin_NETGEN_3D
+  {
+  };
+
   /*!
    * NETGENPlugin_NETGEN_2D: interface of "Netgen 1D-2D" algorithm
    */
@@ -67,6 +74,13 @@ module NETGENPlugin
   {
   };
 
+  /*!
+   * NETGENPlugin_NETGEN_2D: interface of "Remote Triangle (Netgen)" algorithm
+   */
+  interface NETGENPlugin_NETGEN_2D_Remote : NETGENPlugin::NETGENPlugin_NETGEN_2D_ONLY
+  {
+  };
+
   /*!
    * NETGENPlugin_Remesher_2D: interface of "NETGEN Remesher" algorithm,
    * generating 2D elements basing on an existing 2D mesh
@@ -140,6 +154,9 @@ module NETGENPlugin
     void    SetWorstElemMeasure(in short val );
     short   GetWorstElemMeasure();
 
+    void    SetNbThreads(in short val );
+    short   GetNbThreads();
+
     void    SetUseDelauney(in boolean toUse);
     boolean GetUseDelauney();
 

idl/NETGENPlugin_NETGEN_VERSION.idl.in

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

resources/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public

src/GUI/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public

src/GUI/NETGENPluginGUI.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/GUI/NETGENPluginGUI.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/GUI/NETGENPluginGUI_HypothesisCreator.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/GUI/NETGENPluginGUI_HypothesisCreator.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/GUI/NETGENPluginGUI_SimpleCreator.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/GUI/NETGENPluginGUI_SimpleCreator.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -17,24 +17,29 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+INCLUDE(UseQtExt)
+
 # --- options ---
 # additional include directories
 INCLUDE_DIRECTORIES(
+  ${QT_INCLUDES}
   ${KERNEL_INCLUDE_DIRS}
   ${GUI_INCLUDE_DIRS}
   ${GEOM_INCLUDE_DIRS}
   ${OpenCASCADE_INCLUDE_DIR}
-  ${NETGEN_INCLUDE_DIRS}
   ${SMESH_INCLUDE_DIRS}
   ${MEDCOUPLING_INCLUDE_DIRS}
   ${Boost_INCLUDE_DIRS}
   ${OMNIORB_INCLUDE_DIR}
   ${PROJECT_BINARY_DIR}/idl
-  ${NETGEN_ZLIB_INCLUDE_DIRS}
 )
 
+#Avoid compilation warnings from netgen headers
+INCLUDE_DIRECTORIES( SYSTEM  ${NETGEN_INCLUDE_DIRS} ${NETGEN_ZLIB_INCLUDE_DIRS} )
+
 # additional preprocessor / compiler flags
 ADD_DEFINITIONS(
+  ${QT_DEFINITIONS}
   ${OMNIORB_DEFINITIONS}
   ${OpenCASCADE_DEFINITIONS}
   ${BOOST_DEFINITIONS}
@@ -63,7 +68,10 @@ SET(_link_LIBRARIES
   ${KERNEL_SalomeNS}
   ${KERNEL_SALOMELocalTrace}
   ${KERNEL_OpUtil}
+  VTK::CommonCore
+  VTK::CommonDataModel
   SalomeIDLNETGENPLUGIN
+  Qt5::Core
 )
 
 # --- headers ---
@@ -91,6 +99,14 @@ SET(NETGENEngine_HEADERS
   NETGENPlugin_Mesher.hxx
   NETGENPlugin_Remesher_2D.hxx
   NETGENPlugin_Defs.hxx
+  NETGENPlugin_DriverParam.hxx
+  NETGENPlugin_NETGEN_3D_SA.hxx
+  NETGENPlugin_NETGEN_2D_SA.hxx
+  NETGENPlugin_NETGEN_1D2D3D_SA.hxx
+  NETGENPlugin_NETGEN_3D_Remote.hxx
+  NETGENPlugin_NETGEN_3D_Remote_i.hxx
+  NETGENPlugin_NETGEN_2D_Remote.hxx
+  NETGENPlugin_NETGEN_2D_Remote_i.hxx
 )
 
 # --- sources ---
@@ -118,6 +134,18 @@ SET(NETGENEngine_SOURCES
   NETGENPlugin_SimpleHypothesis_3D_i.cxx
   NETGENPlugin_Remesher_2D.cxx
   NETGENPlugin_i.cxx
+  NETGENPlugin_DriverParam.cxx
+  NETGENPlugin_NETGEN_3D_SA.cxx
+  NETGENPlugin_NETGEN_2D_SA.cxx
+  NETGENPlugin_NETGEN_1D2D3D_SA.cxx
+  NETGENPlugin_NETGEN_3D_Remote.cxx
+  NETGENPlugin_NETGEN_3D_Remote_i.cxx
+  NETGENPlugin_NETGEN_2D_Remote.cxx
+  NETGENPlugin_NETGEN_2D_Remote_i.cxx
+)
+
+SET(NetgenRunner_SOURCES
+  NETGENPlugin_Runner_main.cxx
 )
 
 # --- scripts ---
@@ -134,6 +162,10 @@ ADD_LIBRARY(NETGENEngine ${NETGENEngine_SOURCES})
 TARGET_LINK_LIBRARIES(NETGENEngine ${_link_LIBRARIES} )
 INSTALL(TARGETS NETGENEngine EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
 
+ADD_EXECUTABLE(NETGENPlugin_Runner ${NetgenRunner_SOURCES})
+TARGET_LINK_LIBRARIES(NETGENPlugin_Runner ${_link_LIBRARIES} NETGENEngine )
+INSTALL(TARGETS NETGENPlugin_Runner EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_BINS})
+
 INSTALL(FILES ${NETGENEngine_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
 
 SALOME_INSTALL_SCRIPTS("${_bin_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/salome/NETGENPlugin)

src/NETGENPlugin/NETGENPluginBuilder.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -42,12 +42,14 @@ NETGEN_VERSION_MAJOR = NETGENPlugin.NETGEN_VERSION_MAJOR
 
 ## Algorithm type: Netgen tetrahedron 3D algorithm, see NETGEN_3D_Algorithm
 NETGEN_3D     = "NETGEN_3D"
+NETGEN_3D_Remote     = "NETGEN_3D_Remote"
 ## Algorithm type: Netgen tetrahedron 1D-2D-3D algorithm, see NETGEN_1D2D3D_Algorithm
 NETGEN_1D2D3D = "NETGEN_2D3D"
 ## Algorithm type: Netgen triangle 1D-2D algorithm, see NETGEN_1D2D_Algorithm
 NETGEN_1D2D   = "NETGEN_2D"
 ## Algorithm type: Netgen triangle 2D algorithm, see NETGEN_2D_Only_Algorithm
 NETGEN_2D     = "NETGEN_2D_ONLY"
+NETGEN_2D_Remote = "NETGEN_2D_Remote"
 ## Algorithm type: Synonim of NETGEN_1D2D3D, see NETGEN_1D2D3D_Algorithm
 NETGEN_FULL   = NETGEN_1D2D3D
 ## Algorithm type: Synonim of NETGEN_3D, see NETGEN_3D_Algorithm
@@ -147,6 +149,12 @@ class NETGEN_Algorithm(Mesh_Algorithm):
         if self.Parameters(): self.params.SetGrowthRate(theRate)
         pass
 
+    ## Sets @c NbThreads parameter
+    #  @param theRate new value of the @c NbThreads parameter
+    def SetNbThreads(self, theNumber):
+        if self.Parameters(): self.params.SetNbThreads(theNumber)
+        pass
+
     ## Creates meshing hypothesis according to the chosen algorithm type
     #  and initializes it with default parameters
     #  @param which hypothesis type; can be either @ref SOLE (default) or @ref SIMPLE
@@ -162,7 +170,7 @@ class NETGEN_Algorithm(Mesh_Algorithm):
                 hypType = "NETGEN_SimpleParameters_3D"
             else:
                 hypType = "NETGEN_Parameters"
-        elif self.algoType == NETGEN_2D:
+        elif self.algoType in [NETGEN_2D, NETGEN_2D_Remote]:
             hypType = "NETGEN_Parameters_2D_ONLY"
         else:
             hypType = "NETGEN_Parameters_3D"
@@ -328,6 +336,7 @@ class NETGEN_1D2D_Algorithm(NETGEN_1D2D3D_Algorithm):
     #  @internal
     docHelper  = "Creates triangle 2D algorithm for faces"
 
+
     ## Private constructor.
     #  @param mesh parent mesh object algorithm is assigned to
     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
@@ -361,6 +370,8 @@ class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
     #  @internal
     docHelper  = "Creates triangle 2D algorithm for faces"
 
+    isDefault = True
+
     ## Private constructor.
     #  @param mesh parent mesh object algorithm is assigned to
     #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
@@ -470,6 +481,64 @@ class NETGEN_3D_Algorithm(NETGEN_Algorithm):
 
     pass # end of NETGEN_3D_Algorithm class
 
+## Tetrahedron 3D algorithm
+#
+#  It can be created by calling smeshBuilder.Mesh.Tetrahedron() or smeshBuilder.Mesh.Tetrahedron( smeshBuilder.NETGEN, geom=0 )
+#
+#  This algorithm generates only 3D (volumes) elements for given geometrical shape
+#  and, in contrast to NETGEN_1D2D3D_Algorithm class, should be used in conjunction
+#  with other 1D and 2D meshing algorithms.
+class NETGEN_3D_Remote_Algorithm(NETGEN_3D_Algorithm):
+
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
+    #  @internal
+    algoType   = NETGEN_3D_Remote
+    ## flag pointing either this algorithm should be used by default in dynamic method
+    #  of smeshBuilder.Mesh class
+    #  @internal
+    isDefault  = False
+    ## doc string of the method
+    #  @internal
+    docHelper  = "Remotely Creates tetrahedron 3D algorithm for solids"
+
+    ## Private constructor.
+    #  @param mesh parent mesh object algorithm is assigned to
+    #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
+    #              if it is @c 0 (default), the algorithm is assigned to the main shape
+    def __init__(self, mesh, geom=0):
+        NETGEN_3D_Algorithm.__init__(self, mesh, geom)
+        pass
+
+    pass # end of NETGEN_3D_Remote_Algorithm class
+
+## Tetrahedron 2D algorithm
+#
+#  It can be created by calling smeshBuilder.Mesh.Triangle() or smeshBuilder.Mesh.Triangle( smeshBuilder.NETGEN, geom=0 )
+#
+class NETGEN_2D_Remote_Algorithm(NETGEN_2D_Only_Algorithm):
+
+    ## type of algorithm used with helper function in smeshBuilder.Mesh class
+    #  @internal
+    algoType   = NETGEN_2D_Remote
+    ## flag pointing either this algorithm should be used by default in dynamic method
+    #  of smeshBuilder.Mesh class
+    #  @internal
+    isDefault  = False
+    ## doc string of the method
+    #  @internal
+    docHelper  = "Remotely Creates triangles in face of solids"
+
+    ## Private constructor.
+    #  @param mesh parent mesh object algorithm is assigned to
+    #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
+    #              if it is @c 0 (default), the algorithm is assigned to the main shape
+    def __init__(self, mesh, geom=0):
+        self.algoType = NETGEN_2D_Remote
+        NETGEN_2D_Only_Algorithm.__init__(self, mesh, geom)
+        pass
+
+    pass # end of NETGEN_2D_Remote_Algorithm class
+
 
 ## Triangle (helper) 1D-2D algorithm
 #

src/NETGENPlugin/NETGENPlugin_Defs.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_DriverParam.cxx

@@ -0,0 +1,225 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  File   : NETGENPlugin_DriverParam.hxx
+//  Author : Yoann AUDOUIN, EDF
+//  Module : NETGEN
+//
+#include "NETGENPlugin_DriverParam.hxx"
+
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cassert>
+
+/**
+ * @brief Print content of a netgen_params
+ *
+ * @param aParams The object to display
+ */
+void printNetgenParams(netgen_params& aParams){
+  if ( aParams.myType == Hypo )
+  {
+    std::cout << "has_netgen_param: " << aParams.has_netgen_param << std::endl;
+    std::cout << "maxh: " << aParams.maxh << std::endl;
+    std::cout << "minh: " << aParams.minh << std::endl;
+    std::cout << "segmentsperedge: " << aParams.segmentsperedge << std::endl;
+    std::cout << "grading: " << aParams.grading << std::endl;
+    std::cout << "curvaturesafety: " << aParams.curvaturesafety << std::endl;
+    std::cout << "secondorder: " << aParams.secondorder << std::endl;
+    std::cout << "quad: " << aParams.quad << std::endl;
+    std::cout << "optimize: " << aParams.optimize << std::endl;
+    std::cout << "fineness: " << aParams.fineness << std::endl;
+    std::cout << "uselocalh: " << aParams.uselocalh << std::endl;
+    std::cout << "merge_solids: " << aParams.merge_solids << std::endl;
+    std::cout << "chordalError: " << aParams.chordalError << std::endl;
+    std::cout << "optsteps2d: " << aParams.optsteps2d << std::endl;
+    std::cout << "optsteps3d: " << aParams.optsteps3d << std::endl;
+    std::cout << "elsizeweight: " << aParams.elsizeweight << std::endl;
+    std::cout << "opterrpow: " << aParams.opterrpow << std::endl;
+    std::cout << "delaunay: " << aParams.delaunay << std::endl;
+    std::cout << "checkoverlap: " << aParams.checkoverlap << std::endl;
+    std::cout << "checkchartboundary: " << aParams.checkchartboundary << std::endl;
+    std::cout << "closeedgefac: " << aParams.closeedgefac << std::endl;
+    std::cout << "nbThreadMesher: " << aParams.nbThreads << std::endl;
+    std::cout << "has_local_size: " << aParams.has_local_size << std::endl;
+    std::cout << "meshsizefilename: " << aParams.meshsizefilename << std::endl;
+    std::cout << "has_maxelementvolume_hyp: " << aParams.has_maxelementvolume_hyp << std::endl;
+    std::cout << "maxElementVolume: " << aParams.maxElementVolume << std::endl;
+    std::cout << "has_LengthFromEdges_hyp: " << aParams.has_LengthFromEdges_hyp << std::endl;
+  }
+}
+
+void importDefaultNetgenParams(const std::string param_file, netgen_params& aParams)
+{
+  std::ifstream myfile(param_file);
+  std::string line;
+  // set the default type!
+  aParams.myType = Hypo;
+
+  std::getline(myfile, line);
+  aParams.has_netgen_param = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.maxh = std::stod(line);
+  std::getline(myfile, line);
+  aParams.minh = std::stod(line);
+  std::getline(myfile, line);
+  aParams.segmentsperedge = std::stod(line);
+  std::getline(myfile, line);
+  aParams.grading = std::stod(line);
+  std::getline(myfile, line);
+  aParams.curvaturesafety = std::stod(line);
+  std::getline(myfile, line);
+  aParams.secondorder = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.quad = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.optimize = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.fineness = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.uselocalh = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.merge_solids = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.chordalError = std::stod(line);
+  std::getline(myfile, line);
+  aParams.optsteps2d = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.optsteps3d = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.elsizeweight = std::stod(line);
+  std::getline(myfile, line);
+  aParams.opterrpow = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.delaunay = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.checkoverlap = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.checkchartboundary = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.closeedgefac = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.nbThreads = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.has_local_size = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.meshsizefilename = line;
+  std::getline(myfile, line);
+  aParams.has_maxelementvolume_hyp = std::stoi(line);
+  std::getline(myfile, line);
+  aParams.maxElementVolume = std::stod(line);
+  std::getline(myfile, line);
+  aParams.maxElementVolume = std::stoi(line);
+  myfile.close();
+}
+
+void importSimple2D3DNetgenParams(const std::string param_file, netgen_params& aParams, bool is3D )
+{
+  std::ifstream myfile(param_file);
+  std::string line;
+
+  aParams.myType = !is3D ? Simple2D : Simple3D;
+  std::getline(myfile, line);
+  aParams.has_netgen_param = std::stoi(line); // 1
+  std::getline(myfile, line);
+  aParams.numberOfSegments = std::stoi(line); // segments      (int)
+  std::getline(myfile, line);
+  aParams.localLength = std::stod(line);      // localLenght  (double)
+  std::getline(myfile, line);
+  aParams.maxElementArea = std::stod(line);   // max area     (double)
+  if ( is3D )
+  {
+    std::getline(myfile, line);
+    aParams.maxElementVol = std::stod(line); // max volume    (double)
+  }    
+  std::getline(myfile, line);
+  aParams.allowQuadrangles = std::stoi(line); // int
+
+  myfile.close();
+};
+
+/**
+ * @brief Import a param_file into a netgen_params structure
+ *
+ * @param param_file Name of the file
+ * @param aParams Structure to fill
+ */
+void importNetgenParams(const std::string param_file, netgen_params& aParams){
+  
+  if ( param_file.find("simple2D") != std::string::npos || param_file.find("simple3D") != std::string::npos /*support simple 2D && 3D*/ )
+  {
+    importSimple2D3DNetgenParams( param_file, aParams, bool(param_file.find("simple3D") != std::string::npos) );
+  }
+  else if ( param_file.find("maxarea") == std::string::npos && param_file.find("lenghtfromedge") == std::string::npos /*hypo file for 2D SA*/)
+  {
+    importDefaultNetgenParams( param_file, aParams );
+  }
+  else
+  {
+    aParams.has_netgen_param = false;
+  }
+};
+
+/**
+ * @brief Writes the content of a netgen_param into a file
+ *
+ * @param param_file the file
+ * @param aParams the object
+ */
+void exportNetgenParams(const std::string param_file, netgen_params& aParams){
+  if ( aParams.myType == Hypo ){
+    std::ofstream myfile(param_file);
+    myfile << aParams.has_netgen_param << std::endl;
+    myfile << aParams.maxh << std::endl;
+    myfile << aParams.minh << std::endl;
+    myfile << aParams.segmentsperedge << std::endl;
+    myfile << aParams.grading << std::endl;
+    myfile << aParams.curvaturesafety << std::endl;
+    myfile << aParams.secondorder << std::endl;
+    myfile << aParams.quad << std::endl;
+    myfile << aParams.optimize << std::endl;
+    myfile << aParams.fineness << std::endl;
+    myfile << aParams.uselocalh << std::endl;
+    myfile << aParams.merge_solids << std::endl;
+    myfile << aParams.chordalError << std::endl;
+    myfile << aParams.optsteps2d << std::endl;
+    myfile << aParams.optsteps3d << std::endl;
+    myfile << aParams.elsizeweight << std::endl;
+    myfile << aParams.opterrpow << std::endl;
+    myfile << aParams.delaunay << std::endl;
+    myfile << aParams.checkoverlap << std::endl;
+    myfile << aParams.checkchartboundary << std::endl;
+    myfile << aParams.closeedgefac << std::endl;
+    myfile << aParams.nbThreads << std::endl;
+    myfile << aParams.has_local_size << std::endl;
+    myfile << aParams.meshsizefilename << std::endl;
+    myfile << aParams.has_maxelementvolume_hyp << std::endl;
+    myfile << aParams.maxElementVolume << std::endl;
+    myfile << aParams.has_LengthFromEdges_hyp << std::endl;
+  }
+  else if ( aParams.myType == Simple2D )
+  {
+    // TODO: Export the 2D && 3D simple versions
+  }
+};

src/NETGENPlugin/NETGENPlugin_DriverParam.hxx

@@ -0,0 +1,99 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  File   : NETGENPlugin_DriverParam.hxx
+//  Author : Yoann AUDOUIN, EDF
+//  Module : NETGEN
+//
+
+#ifndef _NETGENPLUGIN_DRIVERPARAM_HXX_
+#define _NETGENPLUGIN_DRIVERPARAM_HXX_
+
+#include <string>
+
+enum hypoType{
+  Hypo = 1, /*the default hypo common for 1D2D,1D2D3D && 3D*/
+  Simple2D,
+  Simple3D
+};
+
+struct netgen_params{
+  // Params from NETGENPlugin_Mesher
+  // True if _hypParameters is not null
+  bool has_netgen_param=true;
+  hypoType myType;
+  double maxh;
+  double minh;
+  double segmentsperedge;
+  double grading;
+  double curvaturesafety;
+  int secondorder;
+  int quad;
+  bool optimize;
+  int fineness;
+  bool uselocalh;
+  bool merge_solids;
+  double chordalError;
+  int optsteps2d;
+  int optsteps3d;
+  double elsizeweight;
+  int opterrpow;
+  bool delaunay;
+  bool checkoverlap;
+  bool checkchartboundary;
+  int closeedgefac;
+
+  // Number of threads for the mesher
+  int nbThreads;
+
+  // True if we have a mesh size file or local size info
+  bool has_local_size = false;
+  std::string meshsizefilename;
+
+  // Params from NETGEN3D
+  // True if _hypMaxElementVolume is not null
+  bool has_maxelementvolume_hyp=false;
+  double maxElementVolume=0.0;
+
+  // Params from NETGEN2D
+  bool has_LengthFromEdges_hyp=false;
+
+  /////////////////////////////////////
+  // Quantities proper of Simple2D
+  int numberOfSegments; // maybe reuse segmentsperedge (?)
+  double localLength;
+  double maxElementArea;
+  bool allowQuadrangles;
+  //// Quantities proper of Simple3D
+  double maxElementVol;
+};
+
+void printNetgenParams(netgen_params& aParams);
+
+void importNetgenParams(const std::string param_file, netgen_params& aParams);
+void importDefaultNetgenParams(const std::string param_file, netgen_params& aParams);
+void importSimple2D3DNetgenParams(const std::string param_file, netgen_params& aParams, bool is3D );
+void exportNetgenParams(const std::string param_file, netgen_params& aParams);
+// TODO symple param to be used with netgen1d2d
+
+
+#endif

src/NETGENPlugin/NETGENPlugin_Hypothesis.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -58,6 +58,7 @@ NETGENPlugin_Hypothesis::NETGENPlugin_Hypothesis (int hypId, SMESH_Gen * gen)
     _nbVolOptSteps      (GetDefaultNbVolOptSteps()),
     _elemSizeWeight     (GetDefaultElemSizeWeight()),
     _worstElemMeasure   (GetDefaultWorstElemMeasure()),
+    _nbThreads          (GetDefaultNbThreads()),
     _surfaceCurvature   (GetDefaultSurfaceCurvature()),
     _useDelauney        (GetDefaultUseDelauney()),
     _checkOverlapping   (GetDefaultCheckOverlapping()),
@@ -436,6 +437,20 @@ void NETGENPlugin_Hypothesis::SetCheckChartBoundary( bool theVal )
   }
 }
 
+//=======================================================================
+//function : SetNbThreads
+//purpose  :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetNbThreads( int theVal )
+{
+  if (theVal != _nbThreads)
+  {
+    _nbThreads = theVal;
+    NotifySubMeshesHypothesisModification();
+  }
+}
+
 //=============================================================================
 /*!
  *

src/NETGENPlugin/NETGENPlugin_Hypothesis.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -35,6 +35,7 @@
 #include "Utils_SALOME_Exception.hxx"
 
 #include <map>
+#include <thread>
 
 //  Parameters for work of NETGEN
 //
@@ -125,6 +126,9 @@ public:
   void   SetCheckChartBoundary( bool toCheck );
   bool   GetCheckChartBoundary() const { return _checkChartBoundary; }
 
+  void   SetNbThreads( int val );
+  int    GetNbThreads() const { return _nbThreads; }
+
   // the default values (taken from NETGEN 4.5 sources)
 
   static Fineness GetDefaultFineness()          { return Moderate; }
@@ -145,6 +149,7 @@ public:
   static bool     GetDefaultCheckOverlapping()  { return true; }
   static bool     GetDefaultCheckChartBoundary(){ return true; }
   static bool     GetDefaultFuseEdges()         { return true; }
+  static int      GetDefaultNbThreads()         { return std::thread::hardware_concurrency(); }
 
   // Persistence
   virtual std::ostream & SaveTo  (std::ostream & save);
@@ -197,6 +202,9 @@ private:
   //bool          _blockFilling; -- not used by netgen
   // (SALOME additions)
   bool          _fuseEdges;
+
+  // Parallelism parameters
+  int _nbThreads;
 };
 
 #endif

src/NETGENPlugin/NETGENPlugin_Hypothesis_2D.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Hypothesis_2D.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_ONLY_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_ONLY_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Hypothesis_3D_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Hypothesis_3D_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Hypothesis_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -566,6 +566,30 @@ CORBA::Short NETGENPlugin_Hypothesis_i::GetWorstElemMeasure()
   return (CORBA::Short) GetImpl()->GetWorstElemMeasure();
 }
 
+//=======================================================================
+//function : SetNbThreads
+//purpose  :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetNbThreads(CORBA::Short val )
+{
+  if ( GetNbThreads() != val )
+  {
+    this->GetImpl()->SetNbThreads( val );
+    SMESH::TPythonDump() << _this() << ".SetNbThreads( " << SMESH::TVar(val) << " )";
+  }
+}
+
+//=======================================================================
+//function : GetNbThreads
+//purpose  :
+//=======================================================================
+
+CORBA::Short NETGENPlugin_Hypothesis_i::GetNbThreads()
+{
+  return (CORBA::Short) GetImpl()->GetNbThreads();
+}
+
 //=======================================================================
 //function : SetUseDelauney
 //purpose  :

src/NETGENPlugin/NETGENPlugin_Hypothesis_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -113,6 +113,9 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Hypothesis_i:
   void    SetWorstElemMeasure(CORBA::Short val );
   CORBA::Short GetWorstElemMeasure();
 
+  void    SetNbThreads(CORBA::Short val );
+  CORBA::Short GetNbThreads();
+
   void    SetUseDelauney(CORBA::Boolean toUse);
   CORBA::Boolean GetUseDelauney();
 

src/NETGENPlugin/NETGENPlugin_Mesher.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -35,9 +35,18 @@
 #include <SMDS_MeshElement.hxx>
 #include <SMESH_Algo.hxx>
 #include <SMESH_ProxyMesh.hxx>
-
+#include <SALOMEDS_Tool.hxx>
+#include "Basics_Utils.hxx"
+#include "SALOME_Basics.hxx"
 #include <TopTools_IndexedMapOfShape.hxx>
 
+// Netgen include files
+#ifndef OCCGEOMETRY
+#define OCCGEOMETRY
+#endif
+#include <occgeom.hpp>
+#include <meshing.hpp>
+
 namespace nglib {
 #include <nglib.h>
 }
@@ -58,7 +67,35 @@ class TopoDS_Shape;
 namespace netgen {
   class OCCGeometry;
   class Mesh;
+  NETGENPLUGIN_DLL_HEADER
+  extern MeshingParameters mparam;
 }
+
+// Class for temporary folder switching
+class ChdirRAII
+{
+  public:
+#ifndef WIN32
+    ChdirRAII(const std::string& wd):_wd(wd) { if(_wd.empty()) return ; char *pwd(get_current_dir_name()); _od = pwd; free(pwd); chdir(_wd.c_str()); }
+    ~ChdirRAII() { if(_od.empty()) return ; chdir(_od.c_str()); }
+#else
+    ChdirRAII(const std::string& wd) : _wd(wd) {
+      if (_wd.empty())
+        return;
+      TCHAR pwd[MAX_PATH];
+      GetCurrentDirectory(sizeof(pwd), pwd);
+      _od = Kernel_Utils::utf8_encode_s(pwd);
+      SetCurrentDirectory(Kernel_Utils::utf8_decode_s(_wd).c_str());
+    }
+    ~ChdirRAII() {
+      if (_od.empty()) return;
+      SetCurrentDirectory(Kernel_Utils::utf8_decode_s(_od).c_str());
+    }
+#endif
+  private:
+    std::string _wd;
+    std::string _od;
+};
 //=============================================================================
 /*!
  * \brief Struct storing nb of entities in netgen mesh
@@ -92,21 +129,28 @@ struct NETGENPLUGIN_EXPORT NETGENPlugin_NetgenLibWrapper
   void setMesh( nglib::Ng_Mesh* mesh );
   nglib::Ng_Mesh* ngMesh() { return (nglib::Ng_Mesh*)(void*)_ngMesh; }
 
+
+
   static int GenerateMesh(netgen::OCCGeometry& occgeo, int startWith, int endWith,
                           netgen::Mesh* & ngMesh);
   int GenerateMesh(netgen::OCCGeometry& occgeo, int startWith, int endWith )
   {
     return GenerateMesh( occgeo, startWith, endWith, _ngMesh );
   }
+
   static void CalcLocalH( netgen::Mesh * ngMesh );
 
   static void RemoveTmpFiles();
   static int& instanceCounter();
+  void setOutputFile(std::string);
 
  private:
   std::string getOutputFileName();
   void        removeOutputFile();
   std::string _outputFileName;
+  // This will change current directory when the class is instanciated and switch
+  ChdirRAII _tmpDir;
+
 
   ostream *       _ngcout;
   ostream *       _ngcerr;
@@ -137,7 +181,56 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Mesher
   void SetLocalSizeForChordalError( netgen::OCCGeometry& occgeo, netgen::Mesh& ngMesh );
   static void SetLocalSize( netgen::OCCGeometry& occgeo, netgen::Mesh& ngMesh );
 
+  
+/**
+ * @brief InitialSetup. Fill occgeo map with geometrical objects not meshed. Fill meshdSM with the already computed
+ *        submeshes, and mesh the internal edges so faces with internal are eventurally properly meshed.
+ *        Define the class members _ngMesh and _occgeom
+ */
+  void InitialSetup( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo, 
+                      list< SMESH_subMesh* >* meshedSM, NETGENPlugin_Internals* internals, 
+                      SMESH_MesherHelper &quadHelper, NETGENPlugin_ngMeshInfo& initState, netgen::MeshingParameters &mparams );
+
+  void InitialSetupSA( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo, 
+                      list< SMESH_subMesh* >* meshedSM, NETGENPlugin_Internals* internals, 
+                      SMESH_MesherHelper &quadHelper, NETGENPlugin_ngMeshInfo& initState, 
+                      netgen::MeshingParameters &mparams, bool useFMapFunction = false );
+
+  void SetBasicMeshParameters( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::MeshingParameters &mparams, netgen::OCCGeometry& occgeo );
+  void SetBasicMeshParametersFor2D( netgen::OCCGeometry& occgeo, vector< const SMDS_MeshNode* >& nodeVec, 
+                                      netgen::MeshingParameters &mparams, NETGENPlugin_Internals* internals, 
+                                        NETGENPlugin_ngMeshInfo& initState );
+  void SetBasicMeshParametersFor3D( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo, 
+                                      vector< const SMDS_MeshNode* >& nodeVec, netgen::MeshingParameters &mparams, 
+                                        NETGENPlugin_Internals* internals, NETGENPlugin_ngMeshInfo& initState, SMESH_MesherHelper &quadHelper, 
+                                          SMESH_Comment& comment );
+  void CallNetgenConstAnalysis( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::MeshingParameters &mparams, netgen::OCCGeometry& occgeo );
+  int CallNetgenMeshEdges( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo );
+  int CallNetgenMeshFaces( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo, SMESH_Comment& comment );
+  int CallNetgenMeshVolumens( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo, SMESH_Comment& comment );
+  void MakeSecondOrder( netgen::MeshingParameters &mparams, netgen::OCCGeometry& occgeo, 
+                          list< SMESH_subMesh* >* meshedSM, NETGENPlugin_ngMeshInfo& initState, SMESH_Comment& comment );
+  int FillInternalElements( NETGENPlugin_NetgenLibWrapper& ngLib, NETGENPlugin_Internals& internals, netgen::OCCGeometry& occgeo,
+                              NETGENPlugin_ngMeshInfo& initState, SMESH_MesherHelper &quadHelper, list< SMESH_subMesh* >* meshedSM );
+  bool Fill2DViscousLayer( netgen::OCCGeometry& occgeo, vector< const SMDS_MeshNode* >& nodeVec, 
+                            NETGENPlugin_Internals* internals, NETGENPlugin_ngMeshInfo& initState );
+
+  bool Fill3DViscousLayerAndQuadAdaptor( netgen::OCCGeometry& occgeo, vector< const SMDS_MeshNode* >& nodeVec, 
+                                          netgen::MeshingParameters &mparams, NETGENPlugin_ngMeshInfo& initState,
+                                          list< SMESH_subMesh* >* meshedSM, SMESH_MesherHelper &quadHelper, int & err );
+
+  int Fill0D1DElements( netgen::OCCGeometry& occgeo, vector< const SMDS_MeshNode* >& nodeVec, list< SMESH_subMesh* >* meshedSM, SMESH_MesherHelper &quadHelper );
+  void FillSMESH( netgen::OCCGeometry& occgeo, NETGENPlugin_ngMeshInfo& initState, vector< const SMDS_MeshNode* >& nodeVec, SMESH_MesherHelper &quadHelper, SMESH_Comment& comment );
+  ///// End definition methods to rewrite function
+  
+  enum DIM {
+    D1 = 1,
+    D2,
+    D3
+  };       
+  
   bool Compute();
+  bool Compute( NETGENPlugin_NetgenLibWrapper& ngLib, vector< const SMDS_MeshNode* >& nodeVec, bool write2SMESH, DIM dim );
 
   bool Evaluate(MapShapeNbElems& aResMap);
 
@@ -209,6 +302,19 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Mesher
 
  private:
 
+  bool Compute1D( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo );
+
+  bool Compute2D( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo,
+                  netgen::MeshingParameters &mparams, list< SMESH_subMesh* >* meshedSM, 
+                  NETGENPlugin_ngMeshInfo& initState, NETGENPlugin_Internals* internals, 
+                  vector< const SMDS_MeshNode* >& nodeVec, SMESH_Comment& comment, DIM dim );
+                  
+  bool Compute3D( NETGENPlugin_NetgenLibWrapper& ngLib, netgen::OCCGeometry& occgeo,
+                  netgen::MeshingParameters &mparams, list< SMESH_subMesh* >* meshedSM, 
+                  NETGENPlugin_ngMeshInfo& initState, NETGENPlugin_Internals* internals, 
+                  vector< const SMDS_MeshNode* >& nodeVec, SMESH_MesherHelper &quadHelper, 
+                  SMESH_Comment& comment);
+
   SMESH_Mesh*          _mesh;
   const TopoDS_Shape&  _shape;
   bool                 _isVolume;

src/NETGENPlugin/NETGENPlugin_NETGEN_1D2D3D_SA.cxx

@@ -0,0 +1,386 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// NETGENPlugin : C++ implementation
+// File   : NETGENPlugin_NETGEN_2D3D_SA.cxx
+// Author : Cesar Conopoima (OCC)
+// Date   : 01/11/2023
+// Project   : SALOME
+//=============================================================================
+//
+
+#include "NETGENPlugin_DriverParam.hxx"
+#include "NETGENPlugin_Hypothesis.hxx"
+#include "NETGENPlugin_SimpleHypothesis_3D.hxx"
+
+#include "NETGENPlugin_NETGEN_2D.hxx"
+#include "NETGENPlugin_NETGEN_1D2D3D_SA.hxx"
+
+#include <SMESHDS_Mesh.hxx>
+#include <SMESH_ControlsDef.hxx>
+#include <SMESH_Gen.hxx>
+#include <SMESH_Mesh.hxx>
+#include <SMESH_MesherHelper.hxx>
+#include <SMESH_DriverShape.hxx>
+#include <SMESH_DriverMesh.hxx>
+#include <utilities.h>
+
+#include <list>
+
+namespace nglib {
+#include <nglib.h>
+}
+#include <meshing.hpp>
+
+using namespace nglib;
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_1D2D3D_SA::NETGENPlugin_NETGEN_1D2D3D_SA()
+  : NETGENPlugin_NETGEN_2D3D(0, new SMESH_Gen())
+{
+  _name = "NETGEN_1D2D3D_SA";  
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_1D2D3D_SA::~NETGENPlugin_NETGEN_1D2D3D_SA()
+{
+}
+
+/**
+ * @brief Check presence and content of orientation file. Implemented for completness and future reference.
+ *
+ * @param element_orientation_file Binary file containing the orientation of surface elemnts
+ * @return true, false
+ */
+bool NETGENPlugin_NETGEN_1D2D3D_SA::checkOrientationFile( const std::string element_orientation_file )
+{
+  if(element_orientation_file.empty()){
+      MESSAGE("No element orientation file");
+      return true;
+    } else {
+      MESSAGE("Reading from elements from file: " << element_orientation_file);
+      // By construction the orientation file written by Remote version has a zero written to mark no need of orientation in 2D meshing
+      int nbElement;
+      std::ifstream df(element_orientation_file, ios::binary|ios::in);
+      df.read((char*)&nbElement, sizeof(int));
+      df.close();
+      return (nbElement == 0);
+    }
+}
+
+/**
+ * @brief fill plugin hypothesis from the netgen_params structure
+ *
+ * @param aParams the structure
+ */
+void NETGENPlugin_NETGEN_1D2D3D_SA::fillHyp(netgen_params aParams)
+{  
+ if( aParams.myType == hypoType::Hypo )
+  {
+    NETGENPlugin_Hypothesis * hypParameters = new NETGENPlugin_Hypothesis(0, GetGen());
+
+    hypParameters->SetMaxSize(aParams.maxh);
+    hypParameters->SetMinSize(aParams.minh);
+    hypParameters->SetNbSegPerEdge(aParams.segmentsperedge);
+    hypParameters->SetGrowthRate(aParams.grading);
+    hypParameters->SetNbSegPerRadius(aParams.curvaturesafety);
+    hypParameters->SetSecondOrder(aParams.secondorder);
+    hypParameters->SetQuadAllowed(aParams.quad);
+    hypParameters->SetOptimize(aParams.optimize);
+    hypParameters->SetFineness((NETGENPlugin_Hypothesis::Fineness)aParams.fineness);
+    hypParameters->SetSurfaceCurvature(aParams.uselocalh);
+    hypParameters->SetFuseEdges(aParams.merge_solids);
+    hypParameters->SetChordalErrorEnabled(aParams.chordalError);
+    if(aParams.optimize){
+      hypParameters->SetNbSurfOptSteps(aParams.optsteps2d);
+      hypParameters->SetNbVolOptSteps(aParams.optsteps3d);
+    }
+    hypParameters->SetElemSizeWeight(aParams.elsizeweight);
+    hypParameters->SetWorstElemMeasure(aParams.opterrpow);
+    hypParameters->SetUseDelauney(aParams.delaunay);
+    hypParameters->SetCheckOverlapping(aParams.checkoverlap);
+    hypParameters->SetCheckChartBoundary(aParams.checkchartboundary);
+    hypParameters->SetMeshSizeFile(aParams.meshsizefilename);
+
+    _hypothesis = dynamic_cast< const NETGENPlugin_Hypothesis *> (hypParameters);
+  }
+  else if ( aParams.myType == hypoType::Simple2D )
+  {
+    NETGENPlugin_SimpleHypothesis_2D * hypParameters = new NETGENPlugin_SimpleHypothesis_2D(0, GetGen());
+    
+    // mandatory to fill in this branch case!
+    // Number of segments   (int)
+    // localLenght          (double)
+    // maxElement area      (double)
+    // GetAllowQuadrangles  (bool)
+    hypParameters->SetNumberOfSegments( aParams.numberOfSegments );
+    if ( !aParams.numberOfSegments )
+      hypParameters->SetLocalLength( aParams.localLength );      
+    hypParameters->SetMaxElementArea( aParams.maxElementArea );
+    hypParameters->SetAllowQuadrangles( aParams.allowQuadrangles );
+    _hypothesis = dynamic_cast< const NETGENPlugin_SimpleHypothesis_2D *> (hypParameters);
+  }
+  else if ( aParams.myType == hypoType::Simple3D )
+  {
+    NETGENPlugin_SimpleHypothesis_3D * hypParameters = new NETGENPlugin_SimpleHypothesis_3D(0, GetGen());
+    
+    // mandatory to fill in this branch case!
+    // Number of segments   (int)
+    // localLenght          (double)
+    // maxElement area      (double)
+    // maxElement volume    (double)
+    // GetAllowQuadrangles  (bool)
+    hypParameters->SetNumberOfSegments( aParams.numberOfSegments );
+    if ( !aParams.numberOfSegments )
+      hypParameters->SetLocalLength( aParams.localLength );      
+    hypParameters->SetMaxElementArea( aParams.maxElementArea );
+    hypParameters->SetMaxElementVolume( aParams.maxElementVol );
+    hypParameters->SetAllowQuadrangles( aParams.allowQuadrangles );
+
+    _hypothesis = dynamic_cast< const NETGENPlugin_SimpleHypothesis_3D *> (hypParameters);
+  }
+}
+
+/**
+ * @brief Write a binary file containing information on the elements/nodes
+ *        created by the netgen mesher
+ *
+ * @param nodeVec mapping between the mesh id and the netgen structure id
+ * @param ngLib Wrapper on netgen library
+ * @param new_element_file Name of the output file
+ * @param NumOfPremeshedNodes Number of nodes in the netgen structure
+ * @return true if there are some error
+ */
+bool NETGENPlugin_NETGEN_1D2D3D_SA::FillNewElementFile( std::vector< const SMDS_MeshNode* > &nodeVec, NETGENPlugin_NetgenLibWrapper &ngLib, 
+                                                        std::string new_element_file, const NETGENPlugin_Mesher::DIM dim )
+{
+
+  // Particularities: As submeshing is not supported nodeVect is empty and NumberOfPremeshedNodes is also zero
+  Ng_Mesh* NetgenMesh  = ngLib.ngMesh();
+  int NetgenNodes       = Ng_GetNP(NetgenMesh);
+  int NetgenSeg2D       = Ng_GetNSeg_2D( NetgenMesh );
+  int NetgenFaces       = Ng_GetNSE(NetgenMesh);
+  int NetgenVols        = Ng_GetNE(NetgenMesh);
+  int segmentId;
+  bool isOK = ( NetgenNodes > 0 && NetgenSeg2D > 0 );
+  if ( isOK && !new_element_file.empty() )
+  {
+    MESSAGE("Writting new elements")
+    std::ofstream df(new_element_file, ios::out|ios::binary);
+
+    double NetgenPoint[3];
+    int    NetgenSegment[2];
+    int    NetgenSurface[8];
+    int    NetgenVolumens[10];
+
+    // Writing nodevec (correspondence netgen numbering mesh numbering)
+    // Number of nodes
+    const int NumOfPremeshedNodes = nodeVec.size();
+    df.write((char*) &NumOfPremeshedNodes, sizeof(int));
+    df.write((char*) &NetgenNodes, sizeof(int));
+
+    for (int nodeIndex = 1 ; nodeIndex <= NumOfPremeshedNodes; ++nodeIndex )
+    {
+      //Id of the point
+      int id = nodeVec.at(nodeIndex)->GetID();
+      df.write((char*) &id, sizeof(int));
+    }
+
+    // Writing all new points
+    for (int nodeIndex = NumOfPremeshedNodes + 1; nodeIndex <= NetgenNodes; ++nodeIndex )
+    {
+      Ng_GetPoint( NetgenMesh, nodeIndex, NetgenPoint );
+      // Coordinates of the point
+      df.write((char *) &NetgenPoint, sizeof(double)*3);
+    }
+
+    if ( dim >= NETGENPlugin_Mesher::D1 )
+    {
+      // create segments at boundaries.
+      df.write((char*) &NetgenSeg2D, sizeof(int));
+      for ( int elemIndex = 1; elemIndex <= NetgenSeg2D; ++elemIndex )
+      {
+        Ng_GetSegment_2D( NetgenMesh, elemIndex, NetgenSegment, &segmentId );
+        df.write((char*) &NetgenSegment, sizeof(int) * 2 );
+      }
+    }
+    if ( dim >= NETGENPlugin_Mesher::D2 ) 
+    {
+      // create surface elements.
+      df.write((char*) &NetgenFaces, sizeof(int));
+      for ( int elemIndex = 1; elemIndex <= NetgenFaces; ++elemIndex )
+      {
+        nglib::Ng_Surface_Element_Type elemType = Ng_GetSurfaceElement( NetgenMesh, elemIndex, NetgenSurface );
+        switch (elemType)
+        {
+          case nglib::NG_TRIG:
+          {
+            df.write((char*) &NetgenSurface, sizeof(int) * 3 );
+            break;
+          }            
+          case nglib::NG_QUAD:
+          {
+            df.write((char*) &NetgenSurface, sizeof(int) * 4 );
+            break;
+          }            
+          case nglib::NG_TRIG6:
+          {
+            df.write((char*) &NetgenSurface, sizeof(int) * 6 );
+            break;
+          }            
+          case nglib::NG_QUAD8:
+          {
+            df.write((char*) &NetgenSurface, sizeof(int) * 8 );
+            break;
+          }
+          default:
+          { break; }         
+        }
+      }
+    }
+    if ( dim >= NETGENPlugin_Mesher::D3 ) 
+    {
+      // create volume elements.
+      df.write((char*) &NetgenVols, sizeof(int));
+      for ( int elemIndex = 1; elemIndex <= NetgenVols; ++elemIndex )
+      {
+        nglib::Ng_Volume_Element_Type elemType =  Ng_GetVolumeElement( NetgenMesh, elemIndex, NetgenVolumens );
+        switch (elemType)
+        {        
+          case nglib::NG_TET:
+          {
+            df.write((char*) &NetgenVolumens, sizeof(int) * 4 );
+            break;
+          } 
+          case nglib::NG_PYRAMID:
+          {
+            df.write((char*) &NetgenVolumens, sizeof(int) * 5 );
+            break;
+          }
+          case nglib::NG_PRISM:
+          {
+            df.write((char*) &NetgenVolumens, sizeof(int) * 6 );
+            break;
+          }
+          case nglib::NG_TET10:
+          {
+            df.write((char*) &NetgenVolumens, sizeof(int) * 10 );
+            break;
+          }
+          default:
+          { break; }
+        }
+      }
+    }          
+    df.close();
+  }
+  return false;
+}
+
+/**
+ * @brief Compute the mesh based on the 
+ *
+ * @param aMesh the read Mesh
+ * @param aShape the loaded shape
+ * @param new_element_file output file containing info the elements created by the mesher
+ * @param output_mesh whether or not write the created elements into the mesh
+ * @param dim the dimension to be meshed.
+ * @return negation of mesh fail: true, false
+ */
+bool NETGENPlugin_NETGEN_1D2D3D_SA::Compute(SMESH_Mesh& aMesh, TopoDS_Shape &aShape, std::string new_element_file, bool output_mesh, NETGENPlugin_Mesher::DIM dim )
+{
+  //
+  netgen::multithread.terminate = 0;
+  NETGENPlugin_Mesher mesher(&aMesh, aShape, /*is3D = */ false );
+  mesher.SetParameters(dynamic_cast<const NETGENPlugin_Hypothesis*>(_hypothesis));
+  if ( dim == NETGENPlugin_Mesher::D3 )
+    mesher.SetParameters(dynamic_cast<const NETGENPlugin_SimpleHypothesis_3D*>(_hypothesis));
+  else
+    mesher.SetParameters(dynamic_cast<const NETGENPlugin_SimpleHypothesis_2D*>(_hypothesis));
+  NETGENPlugin_NetgenLibWrapper ngLib;
+  vector< const SMDS_MeshNode* > nodeVec;
+  bool err = mesher.Compute( ngLib, nodeVec, output_mesh, dim );  
+  FillNewElementFile( nodeVec, ngLib, new_element_file, dim );
+  return err;
+}
+
+/**
+ * @brief Running the mesher on the given files
+ *
+ * @param input_mesh_file Mesh file (containing 2D elements)
+ * @param shape_file Shape file (BREP or STEP format)
+ * @param hypo_file Ascii file containing the netgen parameters
+ * @param element_orientation_file Binary file containing the orientation of surface elemnts
+ * @param new_element_file output file containing info the elements created by the mesher
+ * @param output_mesh_file output mesh file (if empty it will not be created)
+ * @return negation of mesh fail: true, false
+ */
+int NETGENPlugin_NETGEN_1D2D3D_SA::run(const std::string input_mesh_file,
+                                      const std::string shape_file,
+                                      const std::string hypo_file,
+                                      const std::string element_orientation_file,
+                                      const std::string new_element_file,
+                                      const std::string output_mesh_file, 
+                                      const NETGENPlugin_Mesher::DIM dim )
+  {
+
+  // _element_orientation_file = element_orientation_file;
+
+  std::unique_ptr<SMESH_Mesh> myMesh(_gen->CreateMesh(false));
+
+  // Importing mesh
+  SMESH_DriverMesh::importMesh(input_mesh_file, *myMesh);
+  // Importing shape
+  TopoDS_Shape myShape;
+  SMESH_DriverShape::importShape(shape_file, myShape);
+  // Importing hypothesis
+  netgen_params myParams;  
+  importNetgenParams(hypo_file, myParams);
+  fillHyp(myParams);
+  int ret = 1;
+
+  if ( checkOrientationFile(element_orientation_file) )
+  {
+    ret = Compute( *myMesh, myShape, new_element_file, !output_mesh_file.empty(), dim );
+    if(ret){
+      std::cerr << "Meshing failed" << std::endl;
+      return ret;
+    }
+
+    if(!output_mesh_file.empty()){
+      std::string meshName = "MESH";
+      SMESH_DriverMesh::exportMesh(output_mesh_file, *myMesh, meshName);
+    }
+  }
+  else
+    std::cerr << "For NETGENPlugin_NETGEN_1D2D3D_SA, orientation file should be market with 0 or be empty!" << std::endl;
+    
+
+  return ret;
+}

src/NETGENPlugin/NETGENPlugin_NETGEN_1D2D3D_SA.hxx

@@ -0,0 +1,63 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// NETGENPlugin : C++ implementation
+// File      : NETGENPlugin_NETGEN_2D_SA.hxx
+// Author    : Cesar Conopoima (OCC)
+// Date      : 23/10/2023
+// Project   : SALOME
+//=============================================================================
+//
+#ifndef _NETGENPlugin_NETGEN_1D2D3D_SA_HXX_
+#define _NETGENPlugin_NETGEN_1D2D3D_SA_HXX_
+
+#include "NETGENPlugin_Defs.hxx"
+#include "NETGENPlugin_Mesher.hxx"
+#include "NETGENPlugin_NETGEN_2D3D.hxx"
+#include "SMESH_Algo.hxx"
+#include "SMESH_Mesh.hxx"
+
+class NETGENPlugin_Mesher;
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_1D2D3D_SA: public NETGENPlugin_NETGEN_2D3D
+{
+public:
+  NETGENPlugin_NETGEN_1D2D3D_SA();
+  virtual ~NETGENPlugin_NETGEN_1D2D3D_SA();
+
+  bool Compute(SMESH_Mesh& aMesh, TopoDS_Shape &aShape, std::string new_element_file, bool output_mesh, NETGENPlugin_Mesher::DIM dim );
+  
+  int run(const std::string input_mesh_file,
+          const std::string shape_file,
+          const std::string hypo_file,
+          const std::string element_orientation_file,
+          const std::string new_element_file,
+          const std::string output_mesh_file,
+          const NETGENPlugin_Mesher::DIM dim );
+
+private:
+  
+  bool checkOrientationFile( const std::string element_orientation_file );
+  void fillHyp(netgen_params aParams);
+  bool FillNewElementFile( std::vector< const SMDS_MeshNode* > &nodeVec, NETGENPlugin_NetgenLibWrapper &ngLib,
+                            std::string new_element_file, const NETGENPlugin_Mesher::DIM dim );
+
+};
+
+#endif

src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -22,12 +22,8 @@
 // Project   : SALOME
 //
 #include "NETGENPlugin_NETGEN_2D_ONLY.hxx"
-
-#include "NETGENPlugin_Mesher.hxx"
 #include "NETGENPlugin_Hypothesis_2D.hxx"
 
-#include <BRepBndLib.hxx>
-#include <TopExp.hxx>
 #include <SMDS_MeshElement.hxx>
 #include <SMDS_MeshNode.hxx>
 #include <SMESHDS_Mesh.hxx>
@@ -48,6 +44,8 @@
 
 #include <utilities.h>
 
+#include <GEOMUtils.hxx>
+
 #include <list>
 #include <vector>
 #include <limits>
@@ -63,6 +61,23 @@ namespace nglib {
 #endif
 #include <occgeom.hpp>
 #include <meshing.hpp>
+
+#include "SMESH_Octree.hxx"
+
+//// Used for node projection in curve
+#include <BRepAdaptor_Curve.hxx>
+#include <BRep_Builder.hxx>
+#include <BRep_Tool.hxx>
+#include <BndLib_Add3dCurve.hxx>
+#include <GCPnts_TangentialDeflection.hxx>
+#include <ShapeAnalysis_Curve.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Compound.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Vertex.hxx>
+
 //#include <meshtype.hpp>
 namespace netgen {
   NETGENPLUGIN_DLL_HEADER
@@ -76,6 +91,264 @@ using namespace std;
 using namespace netgen;
 using namespace nglib;
 
+namespace // copied class from StdMesher_Importe_1D   
+{
+  /*!
+  * \brief Compute point position on a curve. Use octree to fast reject far points
+  */
+  class CurveProjector : public SMESH_Octree
+  {
+  public:
+    CurveProjector( const TopoDS_Edge& edge, double enlarge );
+
+    bool IsOnCurve( const gp_XYZ& point, double & distance2, double & u );
+
+    bool IsOut( const gp_XYZ& point ) const { return getBox()->IsOut( point ); }
+
+  protected:
+    CurveProjector() {}
+    SMESH_Octree* newChild() const { return new CurveProjector; }
+    void          buildChildrenData();
+    Bnd_B3d*      buildRootBox();
+
+  private:
+    struct CurveSegment : public Bnd_B3d
+    {
+      double _chord, _chord2, _length2;
+      gp_Pnt _pFirst, _pLast;
+      gp_Lin _line;
+      Handle(Geom_Curve) _curve;
+
+      CurveSegment() {}
+      void Init( const gp_Pnt& pf, const gp_Pnt& pl,
+                 double uf, double ul, double tol, Handle(Geom_Curve)& curve );
+      bool IsOn( const gp_XYZ& point, double & distance2, double & u );
+      bool IsInContact( const Bnd_B3d& bb );
+    };
+    std::vector< CurveSegment > _segments;
+  };
+
+    //===============================================================================
+  /*!
+   * \brief Create an octree of curve segments
+   */
+  //================================================================================
+
+  CurveProjector::CurveProjector( const TopoDS_Edge& edge, double enlarge )
+    :SMESH_Octree( 0 )
+  {
+    double f,l;
+    Handle(Geom_Curve) curve = BRep_Tool::Curve( edge, f, l );
+    double curDeflect = 0.3; // Curvature deflection
+    double angDeflect = 1e+100; // Angular deflection - don't control chordal error
+    GCPnts_TangentialDeflection div( BRepAdaptor_Curve( edge ), angDeflect, curDeflect );
+    _segments.resize( div.NbPoints() - 1 );
+    for ( int i = 1; i < div.NbPoints(); ++i )
+      try {
+        _segments[ i - 1 ].Init( div.Value( i ),     div.Value( i+1 ),
+                                 div.Parameter( i ), div.Parameter( i+1 ),
+                                 enlarge, curve );
+      }
+      catch ( Standard_Failure& ) {
+        _segments.resize( _segments.size() - 1 );
+        --i;
+      }
+    if ( _segments.size() < 3 )
+      myIsLeaf = true;
+
+    compute();
+
+    if ( _segments.size() == 1 )
+      myBox->Enlarge( enlarge );
+  }
+
+  //================================================================================
+  /*!
+   * \brief Return the maximal box
+   */
+  //================================================================================
+
+  Bnd_B3d* CurveProjector::buildRootBox()
+  {
+    Bnd_B3d* box = new Bnd_B3d;
+    for ( size_t i = 0; i < _segments.size(); ++i )
+      box->Add( _segments[i] );
+    return box;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Redistribute segments among children
+   */
+  //================================================================================
+
+  void CurveProjector::buildChildrenData()
+  {
+    bool allIn = true;
+    for ( size_t i = 0; i < _segments.size(); ++i )
+    {
+      for (int j = 0; j < 8; j++)
+      {
+        if ( _segments[i].IsInContact( *myChildren[j]->getBox() ))
+          ((CurveProjector*)myChildren[j])->_segments.push_back( _segments[i]);
+        else
+          allIn = false;
+      }
+    }
+    if ( allIn && _segments.size() < 3 )
+    {
+      myIsLeaf = true;
+      for (int j = 0; j < 8; j++)
+        static_cast<CurveProjector*>( myChildren[j])->myIsLeaf = true;
+    }
+    else
+    {
+      SMESHUtils::FreeVector( _segments ); // = _segments.clear() + free memory
+
+      for (int j = 0; j < 8; j++)
+      {
+        CurveProjector* child = static_cast<CurveProjector*>( myChildren[j]);
+        if ( child->_segments.size() < 3 )
+          child->myIsLeaf = true;
+      }
+    }
+  }
+
+  //================================================================================
+  /*!
+   * \brief Return true if a point is close to the curve
+   *  \param [in] point - the point
+   *  \param [out] distance2 - distance to the curve
+   *  \param [out] u - parameter on the curve
+   *  \return bool - is the point is close to the curve
+   */
+  //================================================================================
+
+  bool CurveProjector::IsOnCurve( const gp_XYZ& point, double & distance2, double & u )
+  {
+    if ( getBox()->IsOut( point ))
+      return false;
+
+    bool ok = false;
+    double dist2, param;
+    distance2 = Precision::Infinite();
+
+    if ( isLeaf() )
+    {
+      for ( size_t i = 0; i < _segments.size(); ++i )
+        if ( !_segments[i].IsOut( point ) &&
+             _segments[i].IsOn( point, dist2, param ) &&
+             dist2 < distance2 )
+        {
+          distance2 = dist2;
+          u         = param;
+          ok        = true;
+        }
+      return ok;
+    }
+    else
+    {
+      for (int i = 0; i < 8; i++)
+        if (((CurveProjector*) myChildren[i])->IsOnCurve( point, dist2, param ) &&
+            dist2 < distance2 )
+        {
+          distance2 = dist2;
+          u         = param;
+          ok        = true;
+        }
+    }
+    return ok;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Initialize
+   */
+  //================================================================================
+
+  void CurveProjector::CurveSegment::Init(const gp_Pnt&       pf,
+                                          const gp_Pnt&       pl,
+                                          const double        uf,
+                                          const double        ul,
+                                          const double        tol,
+                                          Handle(Geom_Curve)& curve )
+  {
+    _pFirst  = pf;
+    _pLast   = pl;
+    _curve   = curve;
+    _length2 = pf.SquareDistance( pl );
+    _line.SetLocation( pf );
+    _line.SetDirection( gp_Vec( pf, pl ));
+    _chord2  = Max( _line.     SquareDistance( curve->Value( uf + 0.25 * ( ul - uf ))),
+                    Max( _line.SquareDistance( curve->Value( uf + 0.5  * ( ul - uf ))),
+                         _line.SquareDistance( curve->Value( uf + 0.75 * ( ul - uf )))));
+    _chord2 *= ( 1.05 * 1.05 ); // +5%
+    _chord2  = Max( tol, _chord2 );
+    _chord   = Sqrt( _chord2 );
+
+    Bnd_Box bb;
+    BndLib_Add3dCurve::Add( GeomAdaptor_Curve( curve, uf, ul ), tol, bb );
+    Add( bb.CornerMin() );
+    Add( bb.CornerMax() );
+  }
+
+  //================================================================================
+  /*!
+   * \brief Return true if a point is close to the curve segment
+   *  \param [in] point - the point
+   *  \param [out] distance2 - distance to the curve
+   *  \param [out] u - parameter on the curve
+   *  \return bool - is the point is close to the curve segment
+   */
+  //================================================================================
+
+  bool CurveProjector::CurveSegment::IsOn( const gp_XYZ& point, double & distance2, double & u )
+  {
+    distance2 = _line.SquareDistance( point );
+    if ( distance2 > _chord2 )
+      return false;
+
+    // check if the point projection falls into the segment range
+    {
+      gp_Vec edge( _pFirst, _pLast );
+      gp_Vec n1p ( _pFirst, point  );
+      u = ( edge * n1p ) / _length2; // param [0,1] on the edge
+      if ( u < 0. )
+      {
+        if ( _pFirst.SquareDistance( point ) > _chord2 )
+          return false;
+      }
+      else if ( u > 1. )
+      {
+        if ( _pLast.SquareDistance( point ) > _chord2 )
+          return false;
+      }
+    }
+    gp_Pnt proj;
+    distance2 = ShapeAnalysis_Curve().Project( _curve, point, Precision::Confusion(),
+                                               proj, u, false );
+    distance2 *= distance2;
+    return true;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Check if the segment is in contact with a box
+   */
+  //================================================================================
+
+  bool CurveProjector::CurveSegment::IsInContact( const Bnd_B3d& bb )
+  {
+    if ( bb.IsOut( _line.Position(), /*isRay=*/true, _chord ))
+      return false;
+
+    gp_Ax1 axRev = _line.Position().Reversed();
+    axRev.SetLocation( _pLast );
+    return !bb.IsOut( axRev, /*isRay=*/true, _chord );
+  }
+
+}
+
 //=============================================================================
 /*!
  *
@@ -219,6 +492,470 @@ bool NETGENPlugin_NETGEN_2D_ONLY::CheckHypothesis (SMESH_Mesh&         aMesh,
 //   }
 // }
 
+
+
+/**
+ * @brief MapSegmentsToEdges. 
+ * @remark To feed 1D segments not associated to any geometry we need:
+ *          1) For each face, check all segments that are in the face (use ShapeAnalysis_Surface class)
+ *          2) Check to which edge the segment below to, use the copied [from StdMesher_Importe_1D] CurveProjector class 
+ *          3) Create new netgen segments with the (u,v) parameters obtained from the ShapeAnalysis_Surface projector
+ *          4) also define the 'param' value of the nodes relative to the edges obtained from CurveProjector
+ *          5) Add the new netgen segments IN ORDER into the netgen::mesh data structure to form a closed chain
+ *          6) Beware with the occ::edge orientation
+ * 
+ * @param aMesh Mesh file (containing 1D elements)
+ * @param aShape Shape file (BREP or STEP format)
+ * @param ngLib netgenlib library wrapper
+ * @param nodeVec vector of nodes used internally to feed smesh aMesh after computation
+ * @param premeshedNodes map of prmeshed nodes and the smesh nodeID associate to it
+ * @param newNetgenCoordinates map of 3D coordinate of new points created by netgen
+ * @param newNetgenElements map of triangular or quadrangular elements ID and the nodes defining the 2D element
+ * @return false
+ */
+bool NETGENPlugin_NETGEN_2D_ONLY::MapSegmentsToEdges(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape, NETGENPlugin_NetgenLibWrapper &ngLib,
+                                                      vector< const SMDS_MeshNode* >& nodeVec, std::map<int,const SMDS_MeshNode*>& premeshedNodes, 
+                                                      std::map<int,std::vector<double>>& newNetgenCoordinates, std::map<int,std::vector<smIdType>>& newNetgenElements )
+{  
+  SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+  SMESH_MesherHelper helper(aMesh);
+  helper.SetElementsOnShape( true );
+  const int numberOfPremeshedNodes = aMesh.NbNodes();
+  TopTools_IndexedMapOfShape faces;
+  TopExp::MapShapes( aShape, TopAbs_FACE, faces );
+  int err = 0;
+  for ( int i = 1; i <= faces.Size(); ++i )
+  {
+    int numOfEdges = 0;
+    int totalEdgeLenght = 0;
+
+    TopoDS_Face face = TopoDS::Face(faces( i ) );
+    Bnd_Box FaceBox;
+    GEOMUtils::PreciseBoundingBox( face, FaceBox );
+    if ( face.Orientation() != TopAbs_FORWARD && face.Orientation() != TopAbs_REVERSED )
+      face.Orientation( TopAbs_FORWARD );
+
+    // Set the occgeom to be meshed and some ngMesh parameteres
+    netgen::OCCGeometry occgeom;
+    netgen::Mesh * ngMesh =  (netgen::Mesh*) ngLib._ngMesh;
+    ngMesh->DeleteMesh();
+
+    occgeom.shape = face;
+    occgeom.fmap.Add( face );
+    occgeom.CalcBoundingBox();
+    occgeom.facemeshstatus.SetSize(1);
+    occgeom.facemeshstatus = 0;
+    occgeom.face_maxh_modified.SetSize(1);
+    occgeom.face_maxh_modified = 0;
+    occgeom.face_maxh.SetSize(1);
+    occgeom.face_maxh = netgen::mparam.maxh;
+
+    // Set the face descriptor
+    const int solidID = 0, faceID = 1; /*always 1 because faces are meshed one by one*/
+    if ( ngMesh->GetNFD() < 1 )
+      ngMesh->AddFaceDescriptor( netgen::FaceDescriptor( faceID, solidID, solidID, 0 ));
+
+    ngMesh->SetGlobalH ( netgen::mparam.maxh );
+    ngMesh->SetMinimalH( netgen::mparam.minh );
+    Box<3> bb = occgeom.GetBoundingBox();
+    bb.Increase (bb.Diam()/10);
+    ngMesh->SetLocalH (bb.PMin(), bb.PMax(), netgen::mparam.grading);  
+    // end set the occgeom to be meshed and some ngMesh parameteres
+
+    Handle(ShapeAnalysis_Surface) sprojector = new ShapeAnalysis_Surface( BRep_Tool::Surface( face ));
+    double tol = BRep_Tool::MaxTolerance( face, TopAbs_FACE );
+    gp_Pnt surfPnt(0,0,0);
+  
+    map<const SMDS_MeshNode*, int > node2ngID;
+    map<int, const SMDS_MeshNode* > ng2smesh;
+    // Figure out which edge is this onde in!
+    TopTools_IndexedMapOfShape edges;
+    TopExp::MapShapes( face, TopAbs_EDGE, edges );
+    TopoDS_Edge meshingEdge;
+    // Check wich nodes are in this face!
+    SMDS_ElemIteratorPtr iteratorElem = meshDS->elementsIterator(SMDSAbs_Edge);
+    std::unique_ptr<CurveProjector> myCurveProjector;
+    while ( iteratorElem->more() ) // loop on elements on a geom face
+    {
+      // check mesh face
+      const SMDS_MeshElement* elem = iteratorElem->next();
+      const SMDS_MeshNode* node0 = elem->GetNode( 0 );
+      const SMDS_MeshNode* node1 = elem->GetNode( 1 );
+      SMESH_NodeXYZ nXYZ0( node0 );
+      SMESH_NodeXYZ nXYZ1( node1 );
+      double segmentLength = ( nXYZ0 - nXYZ1 ).Modulus();
+      nXYZ0 += nXYZ1;
+      nXYZ0 /= 2.0;
+      if( FaceBox.IsOut( nXYZ0 ) )
+        continue;      
+
+      gp_XY uv = sprojector->ValueOfUV( nXYZ0, tol ).XY();
+      surfPnt = sprojector->Value( uv );
+      double dist = surfPnt.Distance( nXYZ0 );
+      
+      // used for the curve projector of edges
+      double geomTol = Precision::Confusion();
+      if ( dist < tol /*element is on face*/ )
+      {
+        numOfEdges++;
+        totalEdgeLenght += segmentLength;
+        int occEdgeIdFound = -1;
+        for ( int edgeId = 1; edgeId <= edges.Size(); ++edgeId ) /*find in which edge the node is placed*/
+        {
+          meshingEdge = TopoDS::Edge(edges( edgeId ));
+          myCurveProjector = std::unique_ptr<CurveProjector>( new CurveProjector(meshingEdge, geomTol) );
+          if ( myCurveProjector->IsOut( nXYZ0 ) /*keep searching*/)
+            continue;
+          else
+          {
+            occEdgeIdFound = edgeId;
+            break;
+          }
+        }
+
+        netgen::Segment seg;
+        for ( size_t nodeId = 0; nodeId < 2; nodeId++)
+        {
+          const SMDS_MeshNode* node = elem->GetNode( nodeId );
+          int ngId = ngMesh->GetNP() + 1;
+          ngId = node2ngID.insert( make_pair( node, ngId )).first->second;
+          if ( ngId > ngMesh->GetNP() /* mean it is a new node to be add to the mesh*/)
+          {
+            // Restric size of mesh based on the edge dimension
+            {
+              SMESH_NodeXYZ nXYZ( node );
+              netgen::Point3d pi(nXYZ.X(), nXYZ.Y(), nXYZ.Z());
+              ngMesh->RestrictLocalH( pi, segmentLength );
+            }
+              
+            netgen::MeshPoint mp( netgen::Point<3> (node->X(), node->Y(), node->Z()) );
+            ngMesh->AddPoint ( mp, 1, netgen::EDGEPOINT );
+            ng2smesh.insert( make_pair(ngId, node) );
+            premeshedNodes.insert( make_pair( (int)node->GetID(), node ) );
+          } 
+          seg[nodeId] = ngId;                // ng node id
+          SMESH_NodeXYZ nXYZ( node );
+          gp_XY uv    = sprojector->ValueOfUV( nXYZ, tol ).XY();
+
+          // Compute the param (relative distance) of the node in relation the edge
+          // fundamental for netgen working properly
+          double dist2, param;
+          if ( myCurveProjector->IsOnCurve( nXYZ, dist2, param ) )
+          {
+            seg.epgeominfo[ nodeId ].dist = param;
+            seg.epgeominfo[ nodeId ].u    = uv.X();
+            seg.epgeominfo[ nodeId ].v    = uv.Y();   
+            seg.epgeominfo[ nodeId ].edgenr = occEdgeIdFound;
+          }       
+        }
+
+        if ( meshingEdge.Orientation() != TopAbs_FORWARD )
+        {
+          swap(seg[0], seg[1]);
+          swap(seg.epgeominfo[0], seg.epgeominfo[1] );
+        }
+        
+        seg.edgenr = ngMesh->GetNSeg() + 1; // netgen segment id
+        seg.si     = faceID;
+        ngMesh->AddSegment( seg );
+      } // end if edge is on the face    
+    } // end iteration on elements
+    
+    // set parameters from _hypLengthFromEdges if needed
+    if ( !_hypParameters && _hypLengthFromEdges && numOfEdges )
+    {
+      netgen::mparam.maxh = totalEdgeLenght / numOfEdges;
+      if ( netgen::mparam.maxh < DBL_MIN )
+        netgen::mparam.maxh = occgeom.GetBoundingBox().Diam();
+
+      occgeom.face_maxh = netgen::mparam.maxh;
+      ngMesh->SetGlobalH ( netgen::mparam.maxh );
+    }    
+    // end set parameters
+
+    ngMesh->CalcSurfacesOfNode();
+    const int startWith = MESHCONST_MESHSURFACE;
+    const int endWith   = MESHCONST_OPTSURFACE;
+    err = ngLib.GenerateMesh(occgeom, startWith, endWith, ngMesh);
+
+    // Ng_Mesh * ngMeshptr = (Ng_Mesh*) ngLib._ngMesh;
+    // int NetgenNodes = Ng_GetNP(ngMeshptr);
+    // int NetgenSeg_2D = Ng_GetNSeg_2D(ngMeshptr);
+    // int NetgenFaces = Ng_GetNSE(ngMeshptr);
+    // std::cout << "\n";
+    // std::cout << "Number of nodes, seg, faces, vols: " << NetgenNodes << ", " << NetgenSeg_2D << ", " << NetgenFaces << "\n";
+    // std::cout << "err from netgen computation: " << err << "\n";
+
+    // ----------------------------------------------------
+    // Fill the SMESHDS with the generated nodes and faces
+    // ----------------------------------------------------
+    nodeVec.clear();
+    FillNodesAndElements( aMesh, helper, ngMesh, nodeVec, ng2smesh, newNetgenCoordinates, newNetgenElements, numberOfPremeshedNodes );
+  } // Face iteration
+
+  return (bool) err;
+}
+
+std::tuple<bool,bool> NETGENPlugin_NETGEN_2D_ONLY::SetParameteres( SMESH_Mesh& aMesh, const TopoDS_Shape& aShape, 
+                                                                  NETGENPlugin_Mesher& aMesher, netgen::Mesh * ngMeshes,
+                                                                  netgen::OCCGeometry& occgeoComm, bool isSubMeshSupported )
+{
+  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+    
+  aMesher.SetParameters( _hypParameters ); // _hypParameters -> netgen::mparam
+  if ( _hypMaxElementArea )
+  {
+    netgen::mparam.maxh = sqrt( 2. * _hypMaxElementArea->GetMaxArea() / sqrt(3.0) );
+  }
+  if ( _hypQuadranglePreference )
+    netgen::mparam.quad = true;
+
+  // local size is common for all FACEs in aShape?
+  const bool isCommonLocalSize = ( !_hypLengthFromEdges && !_hypMaxElementArea && netgen::mparam.uselocalh );
+  const bool isDefaultHyp = ( !_hypLengthFromEdges && !_hypMaxElementArea && !_hypParameters );
+
+  if ( isCommonLocalSize ) // compute common local size in ngMeshes[0]
+  {
+    aMesher.PrepareOCCgeometry( occgeoComm, aShape, aMesh );//, meshedSM );
+
+    // local size set at MESHCONST_ANALYSE step depends on
+    // minh, face_maxh, grading and curvaturesafety; find minh if not set by the user
+    if ( !_hypParameters || netgen::mparam.minh < DBL_MIN )
+    {
+      if ( !_hypParameters )
+        netgen::mparam.maxh = occgeoComm.GetBoundingBox().Diam() / 3.;
+      netgen::mparam.minh = aMesher.GetDefaultMinSize( aShape, netgen::mparam.maxh );
+    }
+    // set local size depending on curvature and NOT closeness of EDGEs
+#ifdef NETGEN_V6
+    const double factor = 2; //netgen::occparam.resthcloseedgefac;
+#else
+    const double factor = netgen::occparam.resthcloseedgefac;
+    netgen::occparam.resthcloseedgeenable = false;
+    netgen::occparam.resthcloseedgefac = 1.0 + netgen::mparam.grading;
+#endif
+    occgeoComm.face_maxh = netgen::mparam.maxh;
+#ifdef NETGEN_V6
+    netgen::OCCParameters occparam;
+    netgen::OCCSetLocalMeshSize( occgeoComm, *ngMeshes, netgen::mparam, occparam );
+#else
+    netgen::OCCSetLocalMeshSize( occgeoComm, *ngMeshes );
+#endif
+    occgeoComm.emap.Clear();
+    occgeoComm.vmap.Clear();
+
+    if ( isSubMeshSupported )
+    {
+      // set local size according to size of existing segments
+      TopTools_IndexedMapOfShape edgeMap;
+      TopExp::MapShapes( aMesh.GetShapeToMesh(), TopAbs_EDGE, edgeMap );
+      for ( int iE = 1; iE <= edgeMap.Extent(); ++iE )
+      {
+        const TopoDS_Shape& edge = edgeMap( iE );
+        if ( SMESH_Algo::isDegenerated( TopoDS::Edge( edge )))
+          continue;
+        SMESHDS_SubMesh* smDS = meshDS->MeshElements( edge );
+        if ( !smDS ) continue;
+        SMDS_ElemIteratorPtr segIt = smDS->GetElements();
+        while ( segIt->more() )
+        {
+          const SMDS_MeshElement* seg = segIt->next();
+          SMESH_TNodeXYZ n1 = seg->GetNode(0);
+          SMESH_TNodeXYZ n2 = seg->GetNode(1);
+          gp_XYZ p = 0.5 * ( n1 + n2 );
+          netgen::Point3d pi(p.X(), p.Y(), p.Z());
+          ngMeshes->RestrictLocalH( pi, factor * ( n1 - n2 ).Modulus() );
+        }
+      }
+    }
+    else
+    {
+      SMDS_ElemIteratorPtr iteratorElem = meshDS->elementsIterator(SMDSAbs_Edge);
+      while ( iteratorElem->more() ) // loop on elements on a geom face
+      {
+        const SMDS_MeshElement* elem = iteratorElem->next();      
+        const SMDS_MeshNode* node0 = elem->GetNode( 0 );
+        const SMDS_MeshNode* node1 = elem->GetNode( 1 );
+        SMESH_NodeXYZ nXYZ0( node0 );
+        SMESH_NodeXYZ nXYZ1( node1 );
+        double segmentLength = ( nXYZ0 - nXYZ1 ).Modulus();
+        gp_XYZ p = 0.5 * ( nXYZ0 + nXYZ1 );
+        netgen::Point3d pi(p.X(), p.Y(), p.Z());
+        ngMeshes->RestrictLocalH( pi, factor * segmentLength );
+      }
+    }
+
+    // set local size defined on shapes
+    aMesher.SetLocalSize( occgeoComm, *ngMeshes );
+    aMesher.SetLocalSizeForChordalError( occgeoComm, *ngMeshes );
+    try {
+      ngMeshes->LoadLocalMeshSize( mparam.meshsizefilename );
+    } catch (NgException & ex) {
+      throw error( COMPERR_BAD_PARMETERS, ex.What() );
+    }
+  }
+
+  return std::make_tuple( isCommonLocalSize, isDefaultHyp );
+}
+
+bool NETGENPlugin_NETGEN_2D_ONLY::ComputeMaxhOfFace( TopoDS_Face& Face, NETGENPlugin_Mesher& aMesher, TSideVector& wires, 
+                                                      netgen::OCCGeometry& occgeoComm, bool isDefaultHyp, bool isCommonLocalSize )
+{
+  size_t nbWires = wires.size();
+  if ( !_hypParameters )
+  {
+    double edgeLength = 0;
+    if (_hypLengthFromEdges )
+    {
+      // compute edgeLength as an average segment length
+      smIdType nbSegments = 0;
+      for ( size_t iW = 0; iW < nbWires; ++iW )
+      {
+        edgeLength += wires[ iW ]->Length();
+        nbSegments += wires[ iW ]->NbSegments();
+      }
+      if ( nbSegments )
+        edgeLength /= double( nbSegments );
+      netgen::mparam.maxh = edgeLength;
+    }
+    else if ( isDefaultHyp )
+    {
+      // set edgeLength by a longest segment
+      double maxSeg2 = 0;
+      for ( size_t iW = 0; iW < nbWires; ++iW )
+      {
+        const UVPtStructVec& points = wires[ iW ]->GetUVPtStruct();
+        if ( points.empty() )
+          return error( COMPERR_BAD_INPUT_MESH );
+        gp_Pnt pPrev = SMESH_TNodeXYZ( points[0].node );
+        for ( size_t i = 1; i < points.size(); ++i )
+        {
+          gp_Pnt p = SMESH_TNodeXYZ( points[i].node );
+          maxSeg2 = Max( maxSeg2, p.SquareDistance( pPrev ));
+          pPrev = p;
+        }
+      }
+      edgeLength = sqrt( maxSeg2 ) * 1.05;
+      netgen::mparam.maxh = edgeLength;
+    }
+    if ( netgen::mparam.maxh < DBL_MIN )
+      netgen::mparam.maxh = occgeoComm.GetBoundingBox().Diam();
+
+    if ( !isCommonLocalSize )
+    {
+      netgen::mparam.minh = aMesher.GetDefaultMinSize( Face, netgen::mparam.maxh );
+    }
+  }
+  return true;
+}
+
+void NETGENPlugin_NETGEN_2D_ONLY::FillNodesAndElements( SMESH_Mesh& aMesh, SMESH_MesherHelper& helper, netgen::Mesh * ngMesh, 
+                                                        vector< const SMDS_MeshNode* >& nodeVec, map<int, const SMDS_MeshNode* >& ng2smesh, 
+                                                        std::map<int,std::vector<double>>& newNetgenCoordinates, 
+                                                        std::map<int,std::vector<smIdType>>& newNetgenElements, const int numberOfPremeshedNodes )
+{
+  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+
+  int nbNodes = ngMesh->GetNP();
+  int nbFaces = ngMesh->GetNSE();
+  nodeVec.resize( nbNodes + 1, 0 );
+  // map to index local node numeration to global numeration used by Remote mesher to write the final global resulting mesh
+  std::map<smIdType,smIdType> local2globalMap;
+  
+  smIdType myNewCoordinateCounter = newNetgenCoordinates.size() > 0 ? newNetgenCoordinates.rbegin()->first + 1: numberOfPremeshedNodes+1;
+  int myNewFaceCounter = newNetgenElements.size() > 0 ? newNetgenElements.rbegin()->first + 1 : 1;
+  // add nodes
+  for ( int ngID = 1; ngID <= nbNodes; ++ngID )
+  {
+    const MeshPoint& ngPoint = ngMesh->Point( ngID );
+    // Check if ngPoint is not already present because was in the premeshed mesh boundary
+    if ( ng2smesh.count( ngID ) == 0 )
+    {
+      std::vector<double> netgenCoordinates = {ngPoint(0), ngPoint(1), ngPoint(2)};
+      SMDS_MeshNode * node = meshDS->AddNode(ngPoint(0), ngPoint(1), ngPoint(2));
+      nodeVec[ ngID ] = node;
+      newNetgenCoordinates.insert( make_pair( myNewCoordinateCounter, std::move(netgenCoordinates)) );
+      local2globalMap.insert( std::make_pair( node->GetID(), myNewCoordinateCounter ) );
+      myNewCoordinateCounter++;
+    }
+    else
+    {
+      nodeVec[ ngID ] = ng2smesh[ ngID ];
+      local2globalMap.insert( std::make_pair( nodeVec[ ngID ]->GetID(), nodeVec[ ngID ]->GetID() ) );
+    }
+  }
+  // create faces
+  int i,j;
+  vector<const SMDS_MeshNode*> nodes;
+  for ( i = 1; i <= nbFaces ; ++i )
+  {
+    const Element2d& elem = ngMesh->SurfaceElement(i);
+    nodes.resize( elem.GetNP() );
+    for (j=1; j <= elem.GetNP(); ++j)
+    {
+      int pind = elem.PNum(j);
+      if ( pind < 1 )
+        break;
+      nodes[ j-1 ] = nodeVec[ pind ];
+    }
+    if ( j > elem.GetNP() )
+    {
+      std::vector<smIdType> netgenCoordinates = { local2globalMap[nodes[0]->GetID()], local2globalMap[nodes[1]->GetID()], local2globalMap[nodes[2]->GetID()] };
+      newNetgenElements.insert( std::make_pair( myNewFaceCounter, std::move( netgenCoordinates ) ) );
+      helper.AddFace(nodes[0],nodes[1],nodes[2]); 
+      myNewFaceCounter++;    
+    }
+  }
+}
+
+void NETGENPlugin_NETGEN_2D_ONLY::FillNodesAndElements( SMESH_Mesh& aMesh, SMESH_MesherHelper& helper, netgen::Mesh * ngMesh, vector< const SMDS_MeshNode* >& nodeVec, int faceId )
+{
+  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+
+  int nbNodes = ngMesh->GetNP();
+  int nbFaces = ngMesh->GetNSE();
+
+  int nbInputNodes = (int) nodeVec.size()-1;
+  nodeVec.resize( nbNodes+1, 0 );
+
+  // add nodes
+  for ( int ngID = nbInputNodes + 1; ngID <= nbNodes; ++ngID )
+  {
+    const MeshPoint& ngPoint = ngMesh->Point( ngID );
+    SMDS_MeshNode * node = meshDS->AddNode(ngPoint(0), ngPoint(1), ngPoint(2));
+    nodeVec[ ngID ] = node;
+  }
+
+  // create faces
+  int i,j;
+  vector<const SMDS_MeshNode*> nodes;
+  for ( i = 1; i <= nbFaces ; ++i )
+  {
+    const Element2d& elem = ngMesh->SurfaceElement(i);
+    nodes.resize( elem.GetNP() );
+    for (j=1; j <= elem.GetNP(); ++j)
+    {
+      int pind = elem.PNum(j);
+      if ( pind < 1 )
+        break;
+      nodes[ j-1 ] = nodeVec[ pind ];
+      if ( nodes[ j-1 ]->GetPosition()->GetTypeOfPosition() == SMDS_TOP_3DSPACE )
+      {
+        const PointGeomInfo& pgi = elem.GeomInfoPi(j);
+        meshDS->SetNodeOnFace( nodes[ j-1 ], faceId, pgi.u, pgi.v);
+      }
+    }
+    if ( j > elem.GetNP() )
+    {
+      if ( elem.GetType() == TRIG )
+        helper.AddFace(nodes[0],nodes[1],nodes[2]);
+      else
+        helper.AddFace(nodes[0],nodes[1],nodes[2],nodes[3]);
+    }
+  }
+}
+  
+
 //=============================================================================
 /*!
  *Here we are going to use the NETGEN mesher
@@ -240,6 +977,7 @@ bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh&         aMesh,
 
   netgen::Mesh   ngMeshNoLocSize;
   netgen::Mesh * ngMeshes[2] = { (netgen::Mesh*) ngLib._ngMesh,  & ngMeshNoLocSize };
+
   netgen::OCCGeometry occgeoComm;
 
   // min / max sizes are set as follows:
@@ -256,83 +994,11 @@ bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh&         aMesh,
   //    max = max segment len of a FACE
 
   NETGENPlugin_Mesher aMesher( &aMesh, aShape, /*isVolume=*/false);
-  aMesher.SetParameters( _hypParameters ); // _hypParameters -> netgen::mparam
+  auto options = SetParameteres( aMesh, aShape, aMesher, ngMeshes[0], occgeoComm );
+  const bool isCommonLocalSize  = std::get<0>( options );
+  const bool isDefaultHyp       = std::get<1>( options );
   const bool toOptimize = _hypParameters ? _hypParameters->GetOptimize() : true;
-  if ( _hypMaxElementArea )
-  {
-    netgen::mparam.maxh = sqrt( 2. * _hypMaxElementArea->GetMaxArea() / sqrt(3.0) );
-  }
-  if ( _hypQuadranglePreference )
-    netgen::mparam.quad = true;
 
-  // local size is common for all FACEs in aShape?
-  const bool isCommonLocalSize = ( !_hypLengthFromEdges && !_hypMaxElementArea && netgen::mparam.uselocalh );
-  const bool isDefaultHyp = ( !_hypLengthFromEdges && !_hypMaxElementArea && !_hypParameters );
-
-  if ( isCommonLocalSize ) // compute common local size in ngMeshes[0]
-  {
-    //list< SMESH_subMesh* > meshedSM[4]; --> all sub-shapes are added to occgeoComm
-    aMesher.PrepareOCCgeometry( occgeoComm, aShape, aMesh );//, meshedSM );
-
-    // local size set at MESHCONST_ANALYSE step depends on
-    // minh, face_maxh, grading and curvaturesafety; find minh if not set by the user
-    if ( !_hypParameters || netgen::mparam.minh < DBL_MIN )
-    {
-      if ( !_hypParameters )
-        netgen::mparam.maxh = occgeoComm.GetBoundingBox().Diam() / 3.;
-      netgen::mparam.minh = aMesher.GetDefaultMinSize( aShape, netgen::mparam.maxh );
-    }
-    // set local size depending on curvature and NOT closeness of EDGEs
-#ifdef NETGEN_V6
-    const double factor = 2; //netgen::occparam.resthcloseedgefac;
-#else
-    const double factor = netgen::occparam.resthcloseedgefac;
-    netgen::occparam.resthcloseedgeenable = false;
-    netgen::occparam.resthcloseedgefac = 1.0 + netgen::mparam.grading;
-#endif
-    occgeoComm.face_maxh = netgen::mparam.maxh;
-#ifdef NETGEN_V6
-    occgeoComm.BuildFMap();
-
-    netgen::OCCParameters occparam;
-    netgen::OCCSetLocalMeshSize( occgeoComm, *ngMeshes[0], netgen::mparam, occparam );
-#else
-    netgen::OCCSetLocalMeshSize( occgeoComm, *ngMeshes[0] );
-#endif
-    occgeoComm.emap.Clear();
-    occgeoComm.vmap.Clear();
-
-    // set local size according to size of existing segments
-    TopTools_IndexedMapOfShape edgeMap;
-    TopExp::MapShapes( aMesh.GetShapeToMesh(), TopAbs_EDGE, edgeMap );
-    for ( int iE = 1; iE <= edgeMap.Extent(); ++iE )
-    {
-      const TopoDS_Shape& edge = edgeMap( iE );
-      if ( SMESH_Algo::isDegenerated( TopoDS::Edge( edge )))
-        continue;
-      SMESHDS_SubMesh* smDS = meshDS->MeshElements( edge );
-      if ( !smDS ) continue;
-      SMDS_ElemIteratorPtr segIt = smDS->GetElements();
-      while ( segIt->more() )
-      {
-        const SMDS_MeshElement* seg = segIt->next();
-        SMESH_TNodeXYZ n1 = seg->GetNode(0);
-        SMESH_TNodeXYZ n2 = seg->GetNode(1);
-        gp_XYZ p = 0.5 * ( n1 + n2 );
-        netgen::Point3d pi(p.X(), p.Y(), p.Z());
-        ngMeshes[0]->RestrictLocalH( pi, factor * ( n1 - n2 ).Modulus() );
-      }
-    }
-
-    // set local size defined on shapes
-    aMesher.SetLocalSize( occgeoComm, *ngMeshes[0] );
-    aMesher.SetLocalSizeForChordalError( occgeoComm, *ngMeshes[0] );
-    try {
-      ngMeshes[0]->LoadLocalMeshSize( mparam.meshsizefilename );
-    } catch (NgException & ex) {
-      return error( COMPERR_BAD_PARMETERS, ex.What() );
-    }
-  }
   netgen::mparam.uselocalh = toOptimize; // restore as it is used at surface optimization
 
   // ==================
@@ -386,50 +1052,9 @@ bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh&         aMesh,
     // compute maxh of a FACE
     // ----------------------
 
-    if ( !_hypParameters )
+    bool setMaxh = ComputeMaxhOfFace( F, aMesher, wires, occgeoComm, isDefaultHyp, isCommonLocalSize );
-    {
+    if (!setMaxh)
-      double edgeLength = 0;
+      return setMaxh;
-      if (_hypLengthFromEdges )
-      {
-        // compute edgeLength as an average segment length
-        smIdType nbSegments = 0;
-        for ( size_t iW = 0; iW < nbWires; ++iW )
-        {
-          edgeLength += wires[ iW ]->Length();
-          nbSegments += wires[ iW ]->NbSegments();
-        }
-        if ( nbSegments )
-          edgeLength /= double( nbSegments );
-        netgen::mparam.maxh = edgeLength;
-      }
-      else if ( isDefaultHyp )
-      {
-        // set edgeLength by a longest segment
-        double maxSeg2 = 0;
-        for ( size_t iW = 0; iW < nbWires; ++iW )
-        {
-          const UVPtStructVec& points = wires[ iW ]->GetUVPtStruct();
-          if ( points.empty() )
-            return error( COMPERR_BAD_INPUT_MESH );
-          gp_Pnt pPrev = SMESH_TNodeXYZ( points[0].node );
-          for ( size_t i = 1; i < points.size(); ++i )
-          {
-            gp_Pnt p = SMESH_TNodeXYZ( points[i].node );
-            maxSeg2 = Max( maxSeg2, p.SquareDistance( pPrev ));
-            pPrev = p;
-          }
-        }
-        edgeLength = sqrt( maxSeg2 ) * 1.05;
-        netgen::mparam.maxh = edgeLength;
-      }
-      if ( netgen::mparam.maxh < DBL_MIN )
-        netgen::mparam.maxh = occgeoComm.GetBoundingBox().Diam();
-
-      if ( !isCommonLocalSize )
-      {
-        netgen::mparam.minh = aMesher.GetDefaultMinSize( F, netgen::mparam.maxh );
-      }
-    }
       
     // prepare occgeom
     netgen::OCCGeometry occgeom;
@@ -550,52 +1175,10 @@ bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh&         aMesh,
         }
       }
 
-
       // ----------------------------------------------------
       // Fill the SMESHDS with the generated nodes and faces
       // ----------------------------------------------------
-
+      FillNodesAndElements( aMesh, helper, ngMesh, nodeVec, faceID );      
-      int nbNodes = ngMesh->GetNP();
-      int nbFaces = ngMesh->GetNSE();
-
-      int nbInputNodes = (int) nodeVec.size()-1;
-      nodeVec.resize( nbNodes+1, 0 );
-
-      // add nodes
-      for ( int ngID = nbInputNodes + 1; ngID <= nbNodes; ++ngID )
-      {
-        const MeshPoint& ngPoint = ngMesh->Point( ngID );
-        SMDS_MeshNode * node = meshDS->AddNode(ngPoint(0), ngPoint(1), ngPoint(2));
-        nodeVec[ ngID ] = node;
-      }
-
-      // create faces
-      int i,j;
-      vector<const SMDS_MeshNode*> nodes;
-      for ( i = 1; i <= nbFaces ; ++i )
-      {
-        const Element2d& elem = ngMesh->SurfaceElement(i);
-        nodes.resize( elem.GetNP() );
-        for (j=1; j <= elem.GetNP(); ++j)
-        {
-          int pind = elem.PNum(j);
-          if ( pind < 1 )
-            break;
-          nodes[ j-1 ] = nodeVec[ pind ];
-          if ( nodes[ j-1 ]->GetPosition()->GetTypeOfPosition() == SMDS_TOP_3DSPACE )
-          {
-            const PointGeomInfo& pgi = elem.GeomInfoPi(j);
-            meshDS->SetNodeOnFace( nodes[ j-1 ], faceID, pgi.u, pgi.v);
-          }
-        }
-        if ( j > elem.GetNP() )
-        {
-          if ( elem.GetType() == TRIG )
-            helper.AddFace(nodes[0],nodes[1],nodes[2]);
-          else
-            helper.AddFace(nodes[0],nodes[1],nodes[2],nodes[3]);
-        }
-      }
 
       break;
     } // two attempts

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -26,6 +26,10 @@
 
 #include <SMESH_Algo.hxx>
 #include <SMESH_Mesh.hxx>
+#include <SMESH_Group.hxx>
+#include <SMESHDS_GroupBase.hxx>
+
+#include "NETGENPlugin_Mesher.hxx"
 
 class StdMeshers_MaxElementArea;
 class StdMeshers_LengthFromEdges;
@@ -59,6 +63,29 @@ public:
   virtual bool Evaluate(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape,
                         MapShapeNbElems& aResMap);
 
+  bool MapSegmentsToEdges(SMESH_Mesh&         aMesh,
+                          const TopoDS_Shape& aShape, 
+                          NETGENPlugin_NetgenLibWrapper &ngLib, 
+                          vector< const SMDS_MeshNode* >& nodeVec, 
+                          std::map<int,const SMDS_MeshNode*>& premeshedNodes, 
+                          std::map<int,std::vector<double>>& newNetgenCoordinates,
+                          std::map<int,std::vector<smIdType>>& newNetgenElements );  
+
+  std::tuple<bool,bool> SetParameteres( SMESH_Mesh& aMesh, const TopoDS_Shape& aShape, 
+                                        NETGENPlugin_Mesher& aMesher,  netgen::Mesh * ngMeshes,
+                                        netgen::OCCGeometry& occgeoComm, bool isSubMeshSupported = true );     
+
+  bool ComputeMaxhOfFace( TopoDS_Face& Face, NETGENPlugin_Mesher& aMesher, TSideVector& wires, 
+                          netgen::OCCGeometry& occgeoComm, bool isDefaultHyp, bool isCommonLocalSize );
+  
+  void FillNodesAndElements( SMESH_Mesh& aMesh, SMESH_MesherHelper& helper, netgen::Mesh * ngMesh, vector< const SMDS_MeshNode* >& nodeVec, int faceId );
+
+ /*!
+ * \brief FillNodesAndElements, fill created triangular elements by netgen to the smesh data structure
+ */
+  void FillNodesAndElements( SMESH_Mesh& aMesh, SMESH_MesherHelper& helper, netgen::Mesh * ngMesh, vector< const SMDS_MeshNode* >& nodeVec, map<int, const SMDS_MeshNode* >& ng2smesh,
+                              std::map<int,std::vector<double>>& newNetgenCoordinates, std::map<int,std::vector<smIdType>>& newNetgenElements, const int numberOfPremeshedNodes );
+
 protected:
   const StdMeshers_MaxElementArea*       _hypMaxElementArea;
   const StdMeshers_LengthFromEdges*      _hypLengthFromEdges;

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote.cxx

@@ -0,0 +1,350 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : NETGENPlugin_NETGEN_2D_Remote.cxx
+// Created   : mardi 12 Decembre 2023
+// Author    : Cesar Conopoima (OCC)
+// Project   : SALOME
+//=============================================================================
+//
+//
+#include "NETGENPlugin_NETGEN_2D_Remote.hxx"
+
+#include "NETGENPlugin_DriverParam.hxx"
+#include "NETGENPlugin_Hypothesis.hxx"
+
+#include "Utils_SALOME_Exception.hxx"
+
+#include <SMESH_Gen.hxx>
+#include <SMESH_Mesh.hxx>
+#include <SMESH_ParallelMesh.hxx>
+#include <SMESH_MesherHelper.hxx>
+#include <SMESH_DriverShape.hxx>
+#include <SMESH_DriverMesh.hxx>
+#include <SMESHDS_Mesh.hxx>
+#include <SMESH_MeshLocker.hxx>
+
+#include <QString>
+#include <QProcess>
+
+#include <boost/filesystem.hpp>
+namespace fs = boost::filesystem;
+/*
+  Netgen include files
+*/
+
+#ifndef OCCGEOMETRY
+#define OCCGEOMETRY
+#endif
+#include <occgeom.hpp>
+
+#ifdef NETGEN_V5
+#include <ngexception.hpp>
+#endif
+#ifdef NETGEN_V6
+#include <core/exception.hpp>
+#endif
+
+namespace nglib {
+#include <nglib.h>
+}
+namespace netgen {
+
+  NETGENPLUGIN_DLL_HEADER
+  extern MeshingParameters mparam;
+
+  NETGENPLUGIN_DLL_HEADER
+  extern volatile multithreadt multithread;
+}
+using namespace nglib;
+
+//=============================================================================
+/*!
+ * Constructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_2D_Remote::NETGENPlugin_NETGEN_2D_Remote(int hypId, SMESH_Gen * gen)
+  : NETGENPlugin_NETGEN_2D_ONLY(hypId, gen)
+{
+  _name = "NETGEN_2D_Remote";
+}
+
+//=============================================================================
+/*!
+ * Destructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_2D_Remote::~NETGENPlugin_NETGEN_2D_Remote()
+{
+}
+
+/**
+ * @brief Fill the structure netgen_param with the information from the hypothesis
+ *
+ * @param hyp the hypothesis
+ * @param aParams the netgen_param structure
+ */
+void NETGENPlugin_NETGEN_2D_Remote::fillParameters(const NETGENPlugin_Hypothesis* hyp, netgen_params &aParams)
+{
+  aParams.myType             = hypoType::Hypo;
+  aParams.maxh               = hyp->GetMaxSize();
+  aParams.minh               = hyp->GetMinSize();
+  aParams.segmentsperedge    = hyp->GetNbSegPerEdge();
+  aParams.grading            = hyp->GetGrowthRate();
+  aParams.curvaturesafety    = hyp->GetNbSegPerRadius();
+  aParams.secondorder        = hyp->GetSecondOrder() ? 1 : 0;
+  aParams.quad               = hyp->GetQuadAllowed() ? 1 : 0;
+  aParams.optimize           = hyp->GetOptimize();
+  aParams.fineness           = hyp->GetFineness();
+  aParams.uselocalh          = hyp->GetSurfaceCurvature();
+  aParams.merge_solids       = hyp->GetFuseEdges();
+  aParams.chordalError       = hyp->GetChordalErrorEnabled() ? hyp->GetChordalError() : -1.;
+  aParams.optsteps2d         = aParams.optimize ? hyp->GetNbSurfOptSteps() : 0;
+  aParams.optsteps3d         = aParams.optimize ? hyp->GetNbVolOptSteps()  : 0;
+  aParams.elsizeweight       = hyp->GetElemSizeWeight();
+  aParams.opterrpow          = hyp->GetWorstElemMeasure();
+  aParams.delaunay           = hyp->GetUseDelauney();
+  aParams.checkoverlap       = hyp->GetCheckOverlapping();
+  aParams.checkchartboundary = hyp->GetCheckChartBoundary();
+#ifdef NETGEN_V6
+  // std::string
+  aParams.meshsizefilename = hyp->GetMeshSizeFile();
+  aParams.closeedgefac = 2;
+  aParams.nbThreads = hyp->GetNbThreads();
+#else
+  // const char*
+  aParams.meshsizefilename = hyp->GetMeshSizeFile();
+  aParams.closeedgefac = 0;
+  aParams.nbThreads = 0;
+#endif
+}
+
+/**
+ * @brief write in a binary file the orientation for each surface element of the mesh
+ *
+ * @param aMesh The mesh
+ * @param aShape the shape associated to the mesh
+ * @param output_file name of the binary file
+ */
+void NETGENPlugin_NETGEN_2D_Remote::exportElementOrientation(const std::string output_file)
+{
+  std::ofstream df(output_file, ios::out|ios::binary);
+  int size=0;
+  df.write((char*)&size, sizeof(int));
+  df.close();
+}
+
+/**
+ * @brief Compute mesh associate to shape
+ *
+ * @param aMesh The mesh
+ * @param aShape The shape
+ * @return true fi there are some error
+ */
+bool NETGENPlugin_NETGEN_2D_Remote::Compute(SMESH_Mesh&         aMesh,
+                                           const TopoDS_Shape& aShape)
+{
+  {
+    SMESH_MeshLocker myLocker(&aMesh);
+    SMESH_Hypothesis::Hypothesis_Status hypStatus;
+    NETGENPlugin_NETGEN_2D_ONLY::CheckHypothesis(aMesh, aShape, hypStatus);
+  }
+  SMESH_ParallelMesh& aParMesh = dynamic_cast<SMESH_ParallelMesh&>(aMesh);
+
+  // Temporary folder for run
+#ifdef WIN32
+  fs::path tmp_folder = aParMesh.GetTmpFolder() / fs::path("Volume-%%%%-%%%%");
+#else
+  fs::path tmp_folder = aParMesh.GetTmpFolder() / fs::unique_path(fs::path("Volume-%%%%-%%%%"));
+#endif
+  fs::create_directories(tmp_folder);
+  // Using MESH2D generated after all triangles where created.
+  fs::path mesh_file=aParMesh.GetTmpFolder() / fs::path("Mesh1D.med"); // read the premeshed elements from 2D version
+  fs::path element_orientation_file=tmp_folder / fs::path("element_orientation.dat");
+  fs::path new_element_file=tmp_folder / fs::path("new_elements.dat");
+  // Not used kept for debug
+  //fs::path output_mesh_file=tmp_folder / fs::path("output_mesh.med");
+  fs::path shape_file=tmp_folder / fs::path("shape.brep");
+  fs::path param_file=tmp_folder / fs::path("netgen_lenghtfromedge.txt"); /*becuase name contain 'lenghtfromedge' set length of 2D from premeshed 1D elements*/
+  fs::path log_file=tmp_folder / fs::path("run.log");
+  fs::path cmd_file=tmp_folder / fs::path("cmd.txt");
+  std::string mesh_name = "MESH";
+
+  {
+    SMESH_MeshLocker myLocker(&aMesh);
+    //Writing Shape
+    SMESH_DriverShape::exportShape(shape_file.string(), aShape);
+
+    //Writing hypo
+    // netgen_params aParams;
+    // fillParameters(_hypParameters, aParams);
+    // exportNetgenParams(param_file.string(), aParams);
+    {
+      // Simply write the file with the proper name
+      std::ofstream myfile(param_file.string());
+      myfile << 1 << std::endl;
+      myfile.close();
+    }
+      
+    // Exporting element orientation
+    exportElementOrientation(element_orientation_file.string());
+  }
+
+  // Calling run_mesher
+  // Path to mesher script
+  fs::path mesher_launcher = fs::path(std::getenv("SMESH_ROOT_DIR"))/
+       fs::path("bin")/
+       fs::path("salome")/
+       fs::path("mesher_launcher.py");
+
+
+  std::string s_program="python3";
+  std::list<std::string> params;
+  params.push_back(mesher_launcher.string());
+  params.push_back("NETGEN2D");
+  params.push_back(mesh_file.string());
+  params.push_back(shape_file.string());
+  params.push_back(param_file.string());
+  params.push_back("--elem-orient-file=" + element_orientation_file.string());
+  params.push_back("--new-element-file=" + new_element_file.string());
+  // params.push_back("--output-mesh-file=" + output_mesh_file.string());
+
+  // Parallelism method parameters
+  int method = aParMesh.GetParallelismMethod();
+  if(method == ParallelismMethod::MultiThread){
+    params.push_back("--method=local");
+  } else if (method == ParallelismMethod::MultiNode){
+    params.push_back("--method=cluster");
+    params.push_back("--resource="+aParMesh.GetResource());
+    params.push_back("--wc-key="+aParMesh.GetWcKey());
+    params.push_back("--nb-proc=1");
+    params.push_back("--nb-proc-per-node="+to_string(aParMesh.GetNbProcPerNode()));
+    params.push_back("--nb-node="+to_string(aParMesh.GetNbNode()));
+    params.push_back("--walltime="+aParMesh.GetWalltime());
+  } else {
+    throw SALOME_Exception("Unknown parallelism method "+method);
+  }
+  std::string cmd = "";
+  cmd += s_program;
+  for(auto arg: params){
+    cmd += " " + arg;
+  }
+  MESSAGE("Running command: ");
+  MESSAGE(cmd);
+  // Writing command in cmd.log
+  {
+    std::ofstream flog(cmd_file.string());
+    flog << cmd << endl;
+  }
+
+  // Building arguments for QProcess
+  QString program = QString::fromStdString(s_program);
+  QStringList arguments;
+  for(auto arg : params){
+    arguments << arg.c_str();
+  }
+
+  QString out_file = log_file.string().c_str();
+  QProcess myProcess;
+  // myProcess.setProcessChannelMode(QProcess::MergedChannels);
+  myProcess.setProcessChannelMode(QProcess::ForwardedChannels);
+  myProcess.setStandardOutputFile(out_file);
+
+  myProcess.start(program, arguments);
+  // Waiting for process to finish (argument -1 make it wait until the end of
+  // the process otherwise it just waits 30 seconds)
+  bool finished = myProcess.waitForFinished(-1);
+  int ret = myProcess.exitCode();
+  if(ret != 0 || !finished){
+    // Run crahed
+    std::string msg = "Issue with mesh_launcher: \n";
+    msg += "See log for more details: " + log_file.string() + "\n";
+    msg += cmd + "\n";
+    throw SALOME_Exception(msg);
+  }
+
+  {
+    SMESH_MeshLocker myLocker(&aMesh);
+    std::ifstream df(new_element_file.string(), ios::binary);
+
+    int totalPremeshedNodes;
+    int NetgenNbOfNodes;
+    int NetgenNbOfNodesNew;
+    int NetgenNbOfTriangles;
+    double NetgenPoint[3];
+    int    NetgenTriangle[3];
+    int nodeID;
+
+    SMESH_MesherHelper helper(aMesh);
+    // This function is mandatory for setElementsOnShape to work
+    helper.IsQuadraticSubMesh(aShape);
+    helper.SetElementsOnShape( true );
+
+    df.read((char*) &totalPremeshedNodes, sizeof(int));
+    // Number of nodes in intial mesh
+    df.read((char*) &NetgenNbOfNodes, sizeof(int));
+    // Number of nodes added by netgen
+    df.read((char*) &NetgenNbOfNodesNew, sizeof(int));
+
+    // Filling nodevec (correspondence netgen numbering mesh numbering)
+    vector< const SMDS_MeshNode* > nodeVec ( NetgenNbOfNodesNew + 2 );
+    SMESHDS_Mesh * meshDS = helper.GetMeshDS();
+    for (int nodeIndex = 1; nodeIndex <= NetgenNbOfNodes; ++nodeIndex )
+    {
+      //Id of the point
+      df.read((char*) &nodeID, sizeof(int));
+      nodeVec.at(nodeID) = meshDS->FindNode(nodeID);
+    }
+
+    // Add new points and update nodeVec
+    for (int nodeIndex = totalPremeshedNodes + 1; nodeIndex <= NetgenNbOfNodesNew; ++nodeIndex )
+    {
+      df.read((char *) &NetgenPoint, sizeof(double)*3);
+      nodeVec.at(nodeIndex) = helper.AddNode(NetgenPoint[0], NetgenPoint[1], NetgenPoint[2]);
+    }
+
+    // Add triangles
+    df.read((char*) &NetgenNbOfTriangles, sizeof(int));
+    for ( int elemIndex = 1; elemIndex <= NetgenNbOfTriangles; ++elemIndex )
+    {
+      df.read((char*) &NetgenTriangle, sizeof(int)*3);
+      if ( nodeVec.at( NetgenTriangle[0] ) && nodeVec.at( NetgenTriangle[1] ) && nodeVec.at( NetgenTriangle[2] ) )
+        helper.AddFace(nodeVec.at( NetgenTriangle[0] ), nodeVec.at( NetgenTriangle[1] ), nodeVec.at( NetgenTriangle[2] ) );            
+    }
+  }
+
+  return true;
+}
+
+/**
+ * @brief Assign submeshes to compute
+ *
+ * @param aSubMesh submesh to add
+ */
+void NETGENPlugin_NETGEN_2D_Remote::setSubMeshesToCompute(SMESH_subMesh * aSubMesh)
+{
+  SMESH_MeshLocker myLocker(aSubMesh->GetFather());
+  SMESH_Algo::setSubMeshesToCompute(aSubMesh);
+}

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote.hxx

@@ -0,0 +1,73 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : NETGENPlugin_NETGEN_2D_Remote.hxx
+// Created   : mardi 12 Decembre 2023
+// Author    : Cesar Conopoima (OCC)
+// Project   : SALOME
+//=============================================================================
+//
+#ifndef _NETGENPlugin_NETGEN_2D_REMOTE_HXX_
+#define _NETGENPlugin_NETGEN_2D_REMOTE_HXX_
+
+#include "NETGENPlugin_NETGEN_2D_ONLY.hxx"
+
+#include <vector>
+#include <map>
+
+class StdMeshers_ViscousLayers;
+class StdMeshers_MaxElementVolume;
+class NETGENPlugin_Hypothesis;
+class NETGENPlugin_NetgenLibWrapper;
+class netgen_params;
+class SMDS_MeshNode;
+
+using namespace std;
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D_Remote: public NETGENPlugin_NETGEN_2D_ONLY
+{
+ public:
+  NETGENPlugin_NETGEN_2D_Remote(int hypId, SMESH_Gen* gen);
+  virtual ~NETGENPlugin_NETGEN_2D_Remote();
+
+  // Function whould not be used with remote Computing
+  bool CheckHypothesis (SMESH_Mesh&         aMesh,
+                        const TopoDS_Shape& aShape,
+                        Hypothesis_Status&  aStatus) override {(void)aMesh;(void)aShape;aStatus = HYP_OK;return true;};
+
+  bool Compute(SMESH_Mesh&         aMesh,
+              const TopoDS_Shape& aShape) override;
+
+  void setSubMeshesToCompute(SMESH_subMesh * aSubMesh) override;
+
+
+ private:
+ void exportElementOrientation(const std::string output_file);
+                                
+  void fillParameters(const NETGENPlugin_Hypothesis* hyp,
+                      netgen_params &aParams);
+
+
+};
+
+#endif

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote_i.cxx

@@ -0,0 +1,77 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  SMESH SMESH_I : idl implementation based on 'SMESH' unit's classes
+//  File   : NETGENPlugin_NETGEN_2D_Remote_i.cxx
+//  Author : Cesar Conopoima (OCC)
+//  Module : NETGENPlugin
+//  $Header$
+//
+#include "NETGENPlugin_NETGEN_2D_Remote_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ *  NETGENPlugin_NETGEN_2D_Remote_i::NETGENPlugin_NETGEN_2D_Remote_i
+ *
+ *  Constructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_2D_Remote_i::NETGENPlugin_NETGEN_2D_Remote_i( PortableServer::POA_ptr thePOA,
+                                                    ::SMESH_Gen*            theGenImpl )
+     : SALOME::GenericObj_i( thePOA ),
+       SMESH_Hypothesis_i( thePOA ),
+       SMESH_Algo_i( thePOA ),
+       SMESH_2D_Algo_i( thePOA )
+{
+  myBaseImpl = new ::NETGENPlugin_NETGEN_2D_Remote( theGenImpl->GetANewId(), theGenImpl );
+}
+
+//=============================================================================
+/*!
+ *  NETGENPlugin_NETGEN_2D_Remote_i::~NETGENPlugin_NETGEN_2D_Remote_i
+ *
+ *  Destructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_2D_Remote_i::~NETGENPlugin_NETGEN_2D_Remote_i()
+{
+}
+
+//=============================================================================
+/*!
+ *  NETGENPlugin_NETGEN_2D_Remote_i::GetImpl
+ *
+ *  Get implementation
+ */
+//=============================================================================
+
+::NETGENPlugin_NETGEN_2D_Remote* NETGENPlugin_NETGEN_2D_Remote_i::GetImpl()
+{
+  return ( ::NETGENPlugin_NETGEN_2D_Remote* )myBaseImpl;
+}
+

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote_i.hxx

@@ -0,0 +1,58 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  SMESH SMESH_I : idl implementation based on 'SMESH' unit's classes
+//  File   : NETGENPlugin_NETGEN_2D_Remote_i.hxx
+//  Author : Cesar Conopoima (OCC)
+//  Module : NETGENPlugin
+//  $Header$
+//
+#ifndef _NETGENPlugin_NETGEN_2D_REMOTE_I_HXX_
+#define _NETGENPlugin_NETGEN_2D_REMOTE_I_HXX_
+
+#include "NETGENPlugin_Defs.hxx"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(NETGENPlugin_Algorithm)
+
+#include "SMESH_2D_Algo_i.hxx"
+#include "NETGENPlugin_NETGEN_2D_Remote.hxx"
+
+// ======================================================
+// NETGEN 2d algorithm
+// ======================================================
+class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D_Remote_i:
+  public virtual POA_NETGENPlugin::NETGENPlugin_NETGEN_2D_Remote,
+  public virtual SMESH_2D_Algo_i
+{
+public:
+  // Constructor
+  NETGENPlugin_NETGEN_2D_Remote_i( PortableServer::POA_ptr thePOA,
+                            ::SMESH_Gen*            theGenImpl );
+  // Destructor
+  virtual ~NETGENPlugin_NETGEN_2D_Remote_i();
+
+  // Get implementation
+  ::NETGENPlugin_NETGEN_2D_Remote* GetImpl();
+};
+
+#endif

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_SA.cxx

@@ -0,0 +1,298 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// NETGENPlugin : C++ implementation
+// File   : NETGENPlugin_NETGEN_2D_SA.cxx
+// Author : Cesar Conopoima (OCC)
+// Date   : 23/10/2023
+// Project   : SALOME
+//=============================================================================
+//
+#include "NETGENPlugin_NETGEN_2D_SA.hxx"
+#include "NETGENPlugin_Hypothesis_2D.hxx"
+#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
+#include "NETGENPlugin_Mesher.hxx"
+
+#include <SMESHDS_Mesh.hxx>
+#include <SMESH_ControlsDef.hxx>
+#include <SMESH_Gen.hxx>
+#include <SMESH_Mesh.hxx>
+#include <SMESH_MesherHelper.hxx>
+#include <SMESH_DriverShape.hxx>
+#include <SMESH_DriverMesh.hxx>
+#include <StdMeshers_LengthFromEdges.hxx>
+#include <StdMeshers_MaxElementArea.hxx>
+#include <utilities.h>
+
+#ifdef WIN32
+#include <filesystem>
+namespace fs = std::filesystem;
+#else
+#include <boost/filesystem.hpp>
+namespace fs = boost::filesystem;
+#endif
+
+namespace nglib {
+#include <nglib.h>
+}
+#include <meshing.hpp>
+
+using namespace nglib;
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_2D_SA::NETGENPlugin_NETGEN_2D_SA()
+  : NETGENPlugin_NETGEN_2D_ONLY(0, new SMESH_Gen())
+{
+  _name = "NETGEN_2D_SA";  
+}
+
+//=============================================================================
+/*!
+ *  
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_2D_SA::~NETGENPlugin_NETGEN_2D_SA()
+{
+}
+
+/**
+ * @brief Check presence and content of orientation file. Implemented for completness and future reference.
+ *
+ * @param element_orientation_file Binary file containing the orientation of surface elemnts
+ * @return true, false
+ */
+bool NETGENPlugin_NETGEN_2D_SA::checkOrientationFile( const std::string element_orientation_file )
+{
+  if(element_orientation_file.empty()){
+      MESSAGE("No element orientation file");
+      return true;
+    } else {
+      MESSAGE("Reading from elements from file: " << element_orientation_file);
+      // By construction the orientation file written by Remote version has a zero written to mark no need of orientation in 2D meshing
+      int nbElement;
+      std::ifstream df(element_orientation_file, ios::binary|ios::in);
+      df.read((char*)&nbElement, sizeof(int));
+      df.close();
+      return (nbElement == 0);
+    }
+}
+
+/**
+ * @brief fill plugin hypothesis from the netgen_params structure
+ *
+ * @param aParams the structure
+ */
+void NETGENPlugin_NETGEN_2D_SA::fillHyp(const std::string param_file, netgen_params aParams)
+{  
+
+  if( aParams.has_netgen_param && aParams.myType == hypoType::Hypo )
+  {
+    NETGENPlugin_Hypothesis_2D * hyp = new NETGENPlugin_Hypothesis_2D(0, GetGen());
+    hyp->SetMaxSize(aParams.maxh);
+    hyp->SetMinSize(aParams.minh);
+    hyp->SetGrowthRate(aParams.grading);
+    hyp->SetQuadAllowed(aParams.quad);
+    hyp->SetFineness((NETGENPlugin_Hypothesis::Fineness)aParams.fineness);
+    hyp->SetChordalErrorEnabled(aParams.chordalError);
+    if(aParams.optimize){
+      hyp->SetNbSurfOptSteps(aParams.optsteps2d);
+    }
+    _hypParameters = dynamic_cast< const NETGENPlugin_Hypothesis_2D *> (hyp);
+  }
+  else 
+  {
+    NETGENPlugin_Hypothesis * hyp = new NETGENPlugin_Hypothesis(0, GetGen());
+    if (param_file.find("lenghtfromedge") != std::string::npos )
+    {
+      _hypLengthFromEdges = dynamic_cast<const StdMeshers_LengthFromEdges*> (hyp);
+    }
+    else if ( param_file.find("maxarea") != std::string::npos )
+    {
+      StdMeshers_MaxElementArea * hyp = new StdMeshers_MaxElementArea(0, GetGen());
+
+      std::ifstream myfile(param_file);
+      std::string line;
+      double maxArea;
+      std::getline(myfile, line);
+      bool hashypothesis = std::stoi(line);
+      if ( hashypothesis )
+      {
+        std::getline(myfile, line);
+        maxArea = std::stod(line);
+        hyp->SetMaxArea( maxArea );
+        _hypMaxElementArea = static_cast<const StdMeshers_MaxElementArea*> (hyp);
+      }
+      
+      myfile.close();
+    }
+  }  
+}
+
+
+/**
+ * @brief Write a binary file containing information on the elements/nodes
+ *        created by the mesher
+ *
+ * @param premeshedNodes map of the premeshed nodes of 1D elements
+ * @param newNetgenCoordinates map of the coordinate of new netgen points created in the mesh
+ * @param newNetgenElements map of the element triangulation
+ * @return true if there are some error
+ */
+bool NETGENPlugin_NETGEN_2D_SA::fillNewElementFile( std::string new_element_file,
+                                                    const int numberOfGlobalPremeshedNodes,
+                                                    std::map<int,const SMDS_MeshNode*>& premeshedNodes, 
+                                                    std::map<int,std::vector<double>>& newNetgenCoordinates,
+                                                    std::map<int,std::vector<smIdType>>& newNetgenElements )
+{
+  MESSAGE("Writting new elements")
+
+  int NetgenNbOfNodes     = premeshedNodes.size();
+  int NetgenNbOfNodesNew  = numberOfGlobalPremeshedNodes + newNetgenCoordinates.size();
+  int NetgenNbOfTriangles = newNetgenElements.size();
+  bool isOK = ( NetgenNbOfTriangles > 0 );
+  if ( isOK && !new_element_file.empty() )
+  {
+    int    NetgenElement[3];
+    std::ofstream df(new_element_file, ios::out|ios::binary);
+    // Writing nodevec (correspondence netgen numbering mesh numbering)
+    // Number of nodes
+    df.write((char*) &numberOfGlobalPremeshedNodes, sizeof(int));
+    df.write((char*) &NetgenNbOfNodes, sizeof(int));
+    df.write((char*) &NetgenNbOfNodesNew, sizeof(int));
+    for (auto k : premeshedNodes )
+      df.write((char*) &k.first, sizeof(int));      
+        
+    // Writing info on new points
+    for (auto k : newNetgenCoordinates )
+      df.write((char*) k.second.data(), sizeof(double)*3 ); 
+      
+    // create triangles
+    df.write((char*) &NetgenNbOfTriangles, sizeof(int));
+    for ( int elemIndex = 1; elemIndex <= NetgenNbOfTriangles; ++elemIndex )
+    {
+      int nodes = newNetgenElements[ elemIndex ].size();
+      for (int i = 0; i < nodes; i++)
+        NetgenElement[ i ] = (int) newNetgenElements[ elemIndex ][ i ];
+      
+      df.write((char*) &NetgenElement, sizeof(int)* nodes );
+    }
+
+    df.close();
+  }
+  return false;
+}
+
+/**
+ * @brief Compute the mesh based on the 
+ *
+ * @param input_mesh_file Mesh file (containing 2D elements)
+ * @param shape_file Shape file (BREP or STEP format)
+ * @param hypo_file Ascii file containing the netgen parameters
+ * @param element_orientation_file Binary file containing the orientation of surface elemnts
+ * @param new_element_file output file containing info the elements created by the mesher
+ * @param output_mesh_file output mesh file (if empty it will not be created)
+ * @return true, false
+ */
+bool NETGENPlugin_NETGEN_2D_SA::Compute( SMESH_Mesh& aMesh, TopoDS_Shape &aShape, std::string new_element_file )
+{
+  // Nodes on edge are double because each face is treat one by one, so seam edges are iterated twice 
+  vector< const SMDS_MeshNode* > nodeVec;
+  NETGENPlugin_Mesher aMesher( &aMesh, aShape, false /*isVolume=*/ );
+  NETGENPlugin_NetgenLibWrapper ngLib;
+  ngLib._isComputeOk = false;
+
+  fs::path netgen_log_file = fs::path(new_element_file).remove_filename() / fs::path("NETGEN.out");
+  MESSAGE("netgen ouput"<<netgen_log_file.string());
+  ngLib.setOutputFile(netgen_log_file.string());
+  
+  netgen::OCCGeometry occgeoComm;
+  NETGENPlugin_NETGEN_2D_ONLY::SetParameteres( aMesh, aShape, aMesher, ngLib._ngMesh, occgeoComm, false /*submesh is not supported*/ );
+
+  std::map<int,const SMDS_MeshNode*> premeshedNodes;
+  std::map<int,std::vector<double>> newNetgenCoordinates;
+  std::map<int,std::vector<smIdType>> newNetgenElements;
+  const int numberOfTotalPremeshedNodes = aMesh.NbNodes();
+  bool compute = NETGENPlugin_NETGEN_2D_ONLY::MapSegmentsToEdges( aMesh, aShape, ngLib, nodeVec,
+                                                                  premeshedNodes, newNetgenCoordinates, 
+                                                                  newNetgenElements );
+  
+  compute = fillNewElementFile(new_element_file, 
+                                numberOfTotalPremeshedNodes, 
+                                premeshedNodes, 
+                                newNetgenCoordinates, 
+                                newNetgenElements);
+  return compute;
+}
+
+/**
+ * @brief Running the mesher on the given files
+ *
+ * @param input_mesh_file Mesh file (containing 2D elements)
+ * @param shape_file Shape file (BREP or STEP format)
+ * @param hypo_file Ascii file containing the netgen parameters
+ * @param element_orientation_file Binary file containing the orientation of surface elemnts
+ * @param new_element_file output file containing info the elements created by the mesher
+ * @param output_mesh_file output mesh file (if empty it will not be created)
+ * @return int
+ */
+int NETGENPlugin_NETGEN_2D_SA::run(const std::string input_mesh_file,
+                                    const std::string shape_file,
+                                    const std::string hypo_file,
+                                    const std::string element_orientation_file,
+                                    const std::string new_element_file,
+                                    const std::string output_mesh_file)
+{
+
+  std::unique_ptr<SMESH_Mesh> myMesh(_gen->CreateMesh(false));
+  
+  SMESH_DriverMesh::importMesh(input_mesh_file, *myMesh);
+  // Importing shape
+  TopoDS_Shape myShape;
+  SMESH_DriverShape::importShape(shape_file, myShape);
+  // Importing hypothesis
+  netgen_params myParams;  
+  importNetgenParams(hypo_file, myParams);
+  fillHyp(hypo_file,myParams);  
+  MESSAGE("Meshing with netgen2d");
+  int ret = 1;
+  if ( checkOrientationFile(element_orientation_file) )
+  {
+    ret = (int) Compute( *myMesh, myShape, new_element_file );
+
+    if(ret){
+      std::cerr << "Meshing failed" << std::endl;
+      return ret;
+    }
+
+    if(!output_mesh_file.empty()){
+      std::string meshName = "MESH";
+      SMESH_DriverMesh::exportMesh(output_mesh_file, *myMesh, meshName);
+    }
+  }
+  else
+    std::cerr << "For NETGENPlugin_NETGEN_2D_SA orientation file should be market with 0 or be empty!" << std::endl;
+
+  return ret;
+}

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_SA.hxx

@@ -0,0 +1,64 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// NETGENPlugin : C++ implementation
+// File      : NETGENPlugin_NETGEN_2D_SA.hxx
+// Author    : Cesar Conopoima (OCC)
+// Date      : 23/10/2023
+// Project   : SALOME
+//=============================================================================
+//
+#ifndef _NETGENPlugin_NETGEN_2D_SA_HXX_
+#define _NETGENPlugin_NETGEN_2D_SA_HXX_
+
+#include "NETGENPlugin_Defs.hxx"
+#include "NETGENPlugin_DriverParam.hxx"
+#include "NETGENPlugin_NETGEN_2D_ONLY.hxx"
+#include "SMESH_Algo.hxx"
+#include "SMESH_Mesh.hxx"
+
+class NETGENPlugin_Mesher;
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D_SA: public NETGENPlugin_NETGEN_2D_ONLY
+{
+public:
+  NETGENPlugin_NETGEN_2D_SA();
+  virtual ~NETGENPlugin_NETGEN_2D_SA();
+
+  bool Compute(SMESH_Mesh& aMesh, TopoDS_Shape &aShape, std::string new_element_file );
+  
+  int run(const std::string input_mesh_file,
+          const std::string shape_file,
+          const std::string hypo_file,
+          const std::string element_orientation_file,
+          const std::string new_element_file,
+          const std::string output_mesh_file);
+
+  bool fillNewElementFile( std::string new_element_file, 
+                           const int numberOfGlobalPremeshedNodes,
+                           std::map<int,const SMDS_MeshNode*>& premeshedNodes, 
+                           std::map<int,std::vector<double>>& newNetgenCoordinates,
+                           std::map<int,std::vector<smIdType>>& newNetgenElements );
+private:
+  
+  bool checkOrientationFile( const std::string element_orientation_file );
+  void fillHyp(const std::string param_file, netgen_params aParams);
+};
+
+#endif

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -45,6 +45,8 @@
 #include <StdMeshers_MaxElementVolume.hxx>
 #include <StdMeshers_QuadToTriaAdaptor.hxx>
 #include <StdMeshers_ViscousLayers.hxx>
+#include <SMESH_subMesh.hxx>
+
 
 #include <BRepGProp.hxx>
 #include <BRep_Tool.hxx>
@@ -63,6 +65,8 @@
 #include <vector>
 #include <map>
 
+#include <cstdlib>
+
 /*
   Netgen include files
 */
@@ -143,8 +147,8 @@ bool NETGENPlugin_NETGEN_3D::CheckHypothesis (SMESH_Mesh&         aMesh,
   _maxElementVolume = DBL_MAX;
 
   // for correct work of GetProgress():
-  netgen::multithread.percent = 0.;
+  //netgen::multithread.percent = 0.;
-  netgen::multithread.task = "Volume meshing";
+  //netgen::multithread.task = "Volume meshing";
   _progressByTic = -1.;
 
   list<const SMESHDS_Hypothesis*>::const_iterator itl;
@@ -186,71 +190,41 @@ bool NETGENPlugin_NETGEN_3D::CheckHypothesis (SMESH_Mesh&         aMesh,
   return aStatus == HYP_OK;
 }
 
+
+
 //=============================================================================
 /*!
  *Here we are going to use the NETGEN mesher
  */
 //=============================================================================
 
-bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
-                                     const TopoDS_Shape& aShape)
-{
-  netgen::multithread.terminate = 0;
-  netgen::multithread.task = "Volume meshing";
-  _progressByTic = -1.;
 
+/**
+ * @brief Compute the list of already meshed Surface elements and info
+ *        on their orientation and if they are internal
+ *
+ * @param aMesh Global Mesh
+ * @param aShape Shape associated to the mesh
+ * @param proxyMesh pointer to mesh used fo find the elements
+ * @param internals information on internal sub shapes
+ * @param helper helper associated to the mesh
+ * @param listElements map of surface element associated with
+ *                     their orientation and internal status
+ * @return true if their was some error
+ */
+bool NETGENPlugin_NETGEN_3D::getSurfaceElements(
+    SMESH_Mesh&         aMesh,
+    const TopoDS_Shape& aShape,
+    SMESH_ProxyMesh::Ptr proxyMesh,
+    NETGENPlugin_Internals &internals,
+    SMESH_MesherHelper &helper,
+    std::map<const SMDS_MeshElement*, tuple<bool, bool>, TIDCompare>& listElements
+)
+{
   SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
-
-  SMESH_MesherHelper helper(aMesh);
-  _quadraticMesh = helper.IsQuadraticSubMesh(aShape);
-  helper.SetElementsOnShape( true );
-
-  int Netgen_NbOfNodes = 0;
-  double Netgen_point[3];
-  int Netgen_triangle[3];
-
-  NETGENPlugin_NetgenLibWrapper ngLib;
-  Ng_Mesh * Netgen_mesh = (Ng_Mesh*)ngLib._ngMesh;
-
-  // vector of nodes in which node index == netgen ID
-  vector< const SMDS_MeshNode* > nodeVec;
-  {
-    const int invalid_ID = -1;
-
-    SMESH::Controls::Area areaControl;
-    SMESH::Controls::TSequenceOfXYZ nodesCoords;
-
-    // maps nodes to ng ID
-    typedef map< const SMDS_MeshNode*, int, TIDCompare > TNodeToIDMap;
-    typedef TNodeToIDMap::value_type                     TN2ID;
-    TNodeToIDMap nodeToNetgenID;
-
-    // find internal shapes
-    NETGENPlugin_Internals internals( aMesh, aShape, /*is3D=*/true );
-
-    // ---------------------------------
-    // Feed the Netgen with surface mesh
-    // ---------------------------------
-
   TopAbs_ShapeEnum mainType = aMesh.GetShapeToMesh().ShapeType();
   bool checkReverse = ( mainType == TopAbs_COMPOUND || mainType == TopAbs_COMPSOLID );
 
-    SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( aMesh ));
-    if ( _viscousLayersHyp )
-    {
-      netgen::multithread.percent = 3;
-      proxyMesh = _viscousLayersHyp->Compute( aMesh, aShape );
-      if ( !proxyMesh )
-        return false;
-    }
-    if ( aMesh.NbQuadrangles() > 0 )
-    {
-      netgen::multithread.percent = 6;
-      StdMeshers_QuadToTriaAdaptor* Adaptor = new StdMeshers_QuadToTriaAdaptor;
-      Adaptor->Compute(aMesh,aShape,proxyMesh.get());
-      proxyMesh.reset( Adaptor );
-    }
-
   for ( TopExp_Explorer exFa( aShape, TopAbs_FACE ); exFa.More(); exFa.Next())
   {
     const TopoDS_Shape& aShapeFace = exFa.Current();
@@ -276,15 +250,107 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
 
       iteratorElem = aSubMeshDSFace->GetElements();
     }
-      while ( iteratorElem->more() ) // loop on elements on a geom face
+    while(iteratorElem->more()){
-      {
-        // check mesh face
       const SMDS_MeshElement* elem = iteratorElem->next();
-        if ( !elem )
+      // check mesh face
+      if ( !elem ){
         return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
-        if ( elem->NbCornerNodes() != 3 )
+      }
+      if ( elem->NbCornerNodes() != 3 ){
         return error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
+      }
+      listElements[elem] = tuple<bool, bool>(isRev, isInternalFace);
+    }
+  }
 
+  return false;
+}
+
+/**
+ * @brief Part of Compute: adding already meshed elements
+ *        into netgen structure
+ *
+ * @param aMesh Global mesh
+ * @param aShape Shape associated with the mesh
+ * @param nodeVec Mapping between nodes mesh id and netgen structure id
+ * @param ngLib Wrapper on netgen lib
+ * @param helper helper assocaited to the mesh
+ * @param Netgen_NbOfNodes Number of nodes in netge structure
+ * @return true if there was some error
+ */
+
+bool NETGENPlugin_NETGEN_3D::computeFillNgMesh(
+  SMESH_Mesh&         aMesh,
+  const TopoDS_Shape& aShape,
+  vector< const SMDS_MeshNode* > &nodeVec,
+  NETGENPlugin_NetgenLibWrapper &ngLib,
+  SMESH_MesherHelper &helper,
+  int &Netgen_NbOfNodes)
+{
+  netgen::multithread.terminate = 0;
+  netgen::multithread.task = "Volume meshing";
+  _progressByTic = -1.;
+
+  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+
+  _quadraticMesh = helper.IsQuadraticSubMesh(aShape);
+  helper.SetElementsOnShape( true );
+
+  Netgen_NbOfNodes = 0;
+  double Netgen_point[3];
+  int Netgen_triangle[3];
+
+  Ng_Mesh * Netgen_mesh = (Ng_Mesh*)ngLib._ngMesh;
+
+  {
+    const int invalid_ID = -1;
+
+    SMESH::Controls::Area areaControl;
+    SMESH::Controls::TSequenceOfXYZ nodesCoords;
+
+    // maps nodes to ng ID
+    // map must be sorted by ID to ensure that we will have the same number of
+    // 3D element if we recompute
+    typedef map< const SMDS_MeshNode*, int, TIDCompare > TNodeToIDMap;
+    typedef TNodeToIDMap::value_type                     TN2ID;
+    TNodeToIDMap nodeToNetgenID;
+
+    // find internal shapes
+    NETGENPlugin_Internals internals( aMesh, aShape, /*is3D=*/true );
+
+    // ---------------------------------
+    // Feed the Netgen with surface mesh
+    // ---------------------------------
+    bool isRev=false;
+    bool isInternalFace=false;
+
+    SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( aMesh ));
+    if ( _viscousLayersHyp )
+    {
+      netgen::multithread.percent = 3;
+      proxyMesh = _viscousLayersHyp->Compute( aMesh, aShape );
+      if ( !proxyMesh )
+        return false;
+    }
+    if ( aMesh.NbQuadrangles() > 0 )
+    {
+      netgen::multithread.percent = 6;
+      StdMeshers_QuadToTriaAdaptor* Adaptor = new StdMeshers_QuadToTriaAdaptor;
+      Adaptor->Compute(aMesh,aShape,proxyMesh.get());
+      proxyMesh.reset( Adaptor );
+    }
+
+    // map must be sorted by ID to ensure that we will have the same number of
+    // 3D element if we recompute
+    std::map<const SMDS_MeshElement*, tuple<bool, bool>, TIDCompare> listElements;
+    bool ret = getSurfaceElements(aMesh, aShape, proxyMesh, internals, helper, listElements);
+    if(ret)
+      return ret;
+
+    for ( auto const& [elem, info] : listElements ) // loop on elements on a geom face
+    {
+      isRev = get<0>(info);
+      isInternalFace = get<1>(info);
       // Add nodes of triangles and triangles them-selves to netgen mesh
 
       // add three nodes of triangle
@@ -326,7 +392,6 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
         Ng_AddSurfaceElement(Netgen_mesh, NG_TRIG, Netgen_triangle);
       }
     } // loop on elements on a face
-    } // loop on faces of a SOLID or SHELL
 
     // insert old nodes into nodeVec
     nodeVec.resize( nodeToNetgenID.size() + 1, 0 );
@@ -344,85 +409,236 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
                                                    internals);
     }
   }
-
+  Netgen_NbOfNodes = Ng_GetNP( Netgen_mesh );
-  // -------------------------
+  return false;
-  // Generate the volume mesh
-  // -------------------------
-
-  return ( ngLib._isComputeOk = compute( aMesh, helper, nodeVec, ngLib ));
 }
 
-// namespace
+/**
-// {
+ * @brief Part of Compute: Setting the netgen parameters from the Hypothesis
-//   void limitVolumeSize( netgen::Mesh* ngMesh,
+ *
-//                         double        maxh )
+ * @param aMesh Global mesh
-//   {
+ * @param ngLib Wrapper on netgen lib
-//     // get average h of faces
+ * @param occgeo Mapping between nodes mesh id and netgen structure id
-//     double faceh = 0;
+ * @param helper helper assocaited to the mesh
-//     int nbh = 0;
+ * @param endWith end step of netgen
-//     for (int i = 1; i <= ngMesh->GetNSE(); i++)
+ * @return true if there was some error
-//     {
+ */
-//       const netgen::Element2d& face = ngMesh->SurfaceElement(i);
+bool NETGENPlugin_NETGEN_3D::computePrepareParam(
-//       for (int j=1; j <= face.GetNP(); ++j)
+  SMESH_Mesh&         aMesh,
-//       {
+  NETGENPlugin_NetgenLibWrapper &ngLib,
-//         const netgen::PointIndex & i1 = face.PNumMod(j);
+  netgen::OCCGeometry &occgeo,
-//         const netgen::PointIndex & i2 = face.PNumMod(j+1);
+  SMESH_MesherHelper &helper,
-//         if ( i1 < i2 )
+  int &endWith)
-//         {
-//           const netgen::Point3d & p1 = ngMesh->Point( i1 );
-//           const netgen::Point3d & p2 = ngMesh->Point( i2 );
-//           faceh += netgen::Dist2( p1, p2 );
-//           nbh++;
-//         }
-//       }
-//     }
-//     faceh = Sqrt( faceh / nbh );
 
-//     double compareh;
+{
-//     if      ( faceh < 0.5 * maxh ) compareh = -1;
+  netgen::multithread.terminate = 0;
-//     else if ( faceh > 1.5 * maxh ) compareh = 1;
-//     else                           compareh = 0;
-//     // cerr << "faceh " << faceh << endl;
-//     // cerr << "init maxh " << maxh << endl;
-//     // cerr << "compareh " << compareh << endl;
 
-//     if ( compareh > 0 )
+  netgen::Mesh* ngMesh = ngLib._ngMesh;
-//       maxh *= 1.2;
-//     else
-//       maxh *= 0.8;
-//     // cerr << "maxh " << maxh << endl;
 
-//     // get bnd box
+  NETGENPlugin_Mesher aMesher( &aMesh, helper.GetSubShape(), /*isVolume=*/true );
-//     netgen::Point3d pmin, pmax;
-//     ngMesh->GetBox( pmin, pmax, 0 );
-//     const double dx = pmax.X() - pmin.X();
-//     const double dy = pmax.Y() - pmin.Y();
-//     const double dz = pmax.Z() - pmin.Z();
 
-//     if ( ! & ngMesh->LocalHFunction() )
+  if ( _hypParameters )
-//       ngMesh->SetLocalH( pmin, pmax, compareh <= 0 ? 0.1 : 0.5 );
+  {
+    aMesher.SetParameters( _hypParameters );
 
-//     // adjusted by SALOME_TESTS/Grids/smesh/bugs_08/I8
+    if ( !_hypParameters->GetLocalSizesAndEntries().empty() ||
-//     const int nbX = Max( 2, int( dx / maxh * 2 ));
+         !_hypParameters->GetMeshSizeFile().empty() )
-//     const int nbY = Max( 2, int( dy / maxh * 2 ));
+    {
-//     const int nbZ = Max( 2, int( dz / maxh * 2 ));
+      if ( ! &ngMesh->LocalHFunction() )
+      {
+        netgen::Point3d pmin, pmax;
+        ngMesh->GetBox( pmin, pmax, 0 );
+        ngMesh->SetLocalH( pmin, pmax, _hypParameters->GetGrowthRate() );
+      }
+      aMesher.SetLocalSize( occgeo, *ngMesh );
 
-//     netgen::Point3d p;
+      try {
-//     for ( int i = 0; i <= nbX; ++i )
+        ngMesh->LoadLocalMeshSize( netgen::mparam.meshsizefilename );
-//     {
+      } catch (netgen::NgException & ex) {
-//       p.X() = pmin.X() +  i * dx / nbX;
+        return error( COMPERR_BAD_PARMETERS, ex.What() );
-//       for ( int j = 0; j <= nbY; ++j )
+      }
-//       {
+    }
-//         p.Y() = pmin.Y() +  j * dy / nbY;
+    if ( !_hypParameters->GetOptimize() )
-//         for ( int k = 0; k <= nbZ; ++k )
+      endWith = netgen::MESHCONST_MESHVOLUME;
-//         {
+  }
-//           p.Z() = pmin.Z() +  k * dz / nbZ;
+  else if ( _hypMaxElementVolume )
-//           ngMesh->RestrictLocalH( p, maxh );
+  {
-//         }
+    netgen::mparam.maxh = pow( 72, 1/6. ) * pow( _maxElementVolume, 1/3. );
-//       }
+    // limitVolumeSize( ngMesh, mparam.maxh ); // result is unpredictable
-//     }
+  }
-//   }
+  else if ( aMesh.HasShapeToMesh() )
-// }
+  {
+    aMesher.PrepareOCCgeometry( occgeo, helper.GetSubShape(), aMesh );
+    netgen::mparam.maxh = occgeo.GetBoundingBox().Diam()/2;
+  }
+  else
+  {
+    netgen::Point3d pmin, pmax;
+    ngMesh->GetBox (pmin, pmax);
+    netgen::mparam.maxh = Dist(pmin, pmax)/2;
+  }
+
+  if ( !_hypParameters && aMesh.HasShapeToMesh() )
+  {
+    netgen::mparam.minh = aMesher.GetDefaultMinSize( helper.GetSubShape(), netgen::mparam.maxh );
+  }
+  return false;
+}
+
+/**
+ * @brief Part of Compute: call to the netgen mesher
+ *
+ * @param occgeo netgen geometry structure
+ * @param nodeVec Mapping between nodes mesh id and netgen structure id
+ * @param ngMesh netgen mesh structure
+ * @param ngLib Wrapper on netgen lib
+ * @param startWith starting step of netgen
+ * @param endWith end step of netgen
+ * @return true if there was some error
+ */
+bool NETGENPlugin_NETGEN_3D::computeRunMesher(
+  netgen::OCCGeometry &occgeo,
+  vector< const SMDS_MeshNode* > &nodeVec,
+  netgen::Mesh* ngMesh,
+  NETGENPlugin_NetgenLibWrapper &ngLib,
+  int &startWith, int &endWith)
+{
+  int err = 1;
+
+  try
+  {
+    OCC_CATCH_SIGNALS;
+
+    ngLib.CalcLocalH(ngMesh);
+    err = ngLib.GenerateMesh(occgeo, startWith, endWith);
+
+    if(netgen::multithread.terminate)
+      return false;
+    if ( err ){
+      error(SMESH_Comment("Error in netgen::OCCGenerateMesh() at ") << netgen::multithread.task);
+    }
+  }
+  catch (Standard_Failure& ex)
+  {
+    SMESH_Comment str("Exception in  netgen::OCCGenerateMesh()");
+    str << " at " << netgen::multithread.task
+        << ": " << ex.DynamicType()->Name();
+    if ( ex.GetMessageString() && strlen( ex.GetMessageString() ))
+      str << ": " << ex.GetMessageString();
+    error(str);
+  }
+  catch (netgen::NgException& exc)
+  {
+    SMESH_Comment str("NgException");
+    if ( strlen( netgen::multithread.task ) > 0 )
+      str << " at " << netgen::multithread.task;
+    str << ": " << exc.What();
+    error(str);
+  }
+  catch (...)
+  {
+    SMESH_Comment str("Exception in  netgen::OCCGenerateMesh()");
+    if ( strlen( netgen::multithread.task ) > 0 )
+      str << " at " << netgen::multithread.task;
+    error(str);
+  }
+
+  if ( err )
+  {
+    SMESH_ComputeErrorPtr ce = NETGENPlugin_Mesher::ReadErrors(nodeVec);
+    if ( ce && ce->HasBadElems() ){
+      error( ce );
+    }
+  }
+
+  return false;
+}
+
+/**
+ * @brief Part of Compute: Adding new element created by mesher to SMESH_Mesh
+ *
+ * @param nodeVec Mapping between nodes mesh id and netgen structure id
+ * @param ngLib Wrapper on netgen lib
+ * @param helper tool associated to the mesh to add element
+ * @param Netgen_NbOfNodes Number of nodes in netgen structure
+ * @return true if there was some error
+ */
+bool NETGENPlugin_NETGEN_3D::computeFillMesh(
+  vector< const SMDS_MeshNode* > &nodeVec,
+  NETGENPlugin_NetgenLibWrapper &ngLib,
+  SMESH_MesherHelper &helper,
+  int &Netgen_NbOfNodes
+  )
+{
+  Ng_Mesh* Netgen_mesh = ngLib.ngMesh();
+
+  int Netgen_NbOfNodesNew = Ng_GetNP(Netgen_mesh);
+  int Netgen_NbOfTetra    = Ng_GetNE(Netgen_mesh);
+
+  bool isOK = ( /*status == NG_OK &&*/ Netgen_NbOfTetra > 0 );// get whatever built
+  if ( isOK )
+  {
+    double Netgen_point[3];
+    int    Netgen_tetrahedron[4];
+
+    // create and insert new nodes into nodeVec
+    nodeVec.resize( Netgen_NbOfNodesNew + 1, 0 );
+    int nodeIndex = Netgen_NbOfNodes + 1;
+    for ( ; nodeIndex <= Netgen_NbOfNodesNew; ++nodeIndex )
+    {
+      Ng_GetPoint( Netgen_mesh, nodeIndex, Netgen_point );
+      nodeVec.at(nodeIndex) = helper.AddNode(Netgen_point[0], Netgen_point[1], Netgen_point[2]);
+    }
+
+    // create tetrahedrons
+    for ( int elemIndex = 1; elemIndex <= Netgen_NbOfTetra; ++elemIndex )
+    {
+      Ng_GetVolumeElement(Netgen_mesh, elemIndex, Netgen_tetrahedron);
+      try
+      {
+        helper.AddVolume (nodeVec.at( Netgen_tetrahedron[0] ),
+                          nodeVec.at( Netgen_tetrahedron[1] ),
+                          nodeVec.at( Netgen_tetrahedron[2] ),
+                          nodeVec.at( Netgen_tetrahedron[3] ));
+      }
+      catch (...)
+      {
+      }
+    }
+  }
+  return false;
+}
+
+
+/**
+ * @brief Compute mesh associate to shape
+ *
+ * @param aMesh The mesh
+ * @param aShape The shape
+ * @return true fi there are some error
+ */
+bool NETGENPlugin_NETGEN_3D::Compute(
+  SMESH_Mesh&         aMesh,
+  const TopoDS_Shape& aShape)
+{
+  // vector of nodes in which node index == netgen ID
+  vector< const SMDS_MeshNode* > nodeVec;
+  NETGENPlugin_NetgenLibWrapper ngLib;
+  SMESH_MesherHelper helper(aMesh);
+  int startWith = netgen::MESHCONST_MESHVOLUME;
+  int endWith   = netgen::MESHCONST_OPTVOLUME;
+  int Netgen_NbOfNodes;
+
+  computeFillNgMesh(aMesh, aShape, nodeVec, ngLib, helper, Netgen_NbOfNodes);
+
+  netgen::OCCGeometry occgeo;
+  computePrepareParam(aMesh, ngLib, occgeo, helper, endWith);
+  computeRunMesher(occgeo, nodeVec, ngLib._ngMesh, ngLib, startWith, endWith);
+
+  computeFillMesh(nodeVec, ngLib, helper, Netgen_NbOfNodes);
+  return false;
+
+}
 
 //================================================================================
 /*!
@@ -475,7 +691,7 @@ bool NETGENPlugin_NETGEN_3D::compute(SMESH_Mesh&                     aMesh,
   else if ( _hypMaxElementVolume )
   {
     netgen::mparam.maxh = pow( 72, 1/6. ) * pow( _maxElementVolume, 1/3. );
-    // limitVolumeSize( ngMesh, netgen::mparam.maxh ); // result is unpredictable
+    // limitVolumeSize( ngMesh, mparam.maxh ); // result is unpredictable
   }
   else if ( aMesh.HasShapeToMesh() )
   {
@@ -701,14 +917,12 @@ double NETGENPlugin_NETGEN_3D::GetProgress() const
          strncmp( netgen::multithread.task, volMeshing, 3 ) == 0 ))
   {
     res = 0.001 + meshingRatio * netgen::multithread.percent / 100.;
-    //cout << netgen::multithread.task << " " <<_progressTic << "-" << netgen::multithread.percent << endl;
   }
   else // different otimizations
   {
     if ( _progressByTic < 0. )
       ((NETGENPlugin_NETGEN_3D*)this)->_progressByTic = meshingRatio / _progressTic;
     res = _progressByTic * _progressTic;
-    //cout << netgen::multithread.task << " " << _progressTic << " " << res << endl;
   }
   return Min ( res, 0.98 );
 }

src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -37,10 +37,15 @@
 #include "SMESH_Algo.hxx"
 #include "Utils_SALOME_Exception.hxx"
 
+#include <vector>
+#include <tuple>
+
 class StdMeshers_ViscousLayers;
 class StdMeshers_MaxElementVolume;
 class NETGENPlugin_Hypothesis;
 class NETGENPlugin_NetgenLibWrapper;
+class netgen_params;
+class SMDS_MeshNode;
 
 class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D: public SMESH_3D_Algo
 {
@@ -66,8 +71,44 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D: public SMESH_3D_Algo
                         const TopoDS_Shape& aShape,
                         MapShapeNbElems& aResMap);
 
+  bool computeFillNgMesh(
+    SMESH_Mesh&         aMesh,
+    const TopoDS_Shape& aShape,
+    std::vector< const SMDS_MeshNode* > &nodeVec,
+    NETGENPlugin_NetgenLibWrapper &ngLib,
+    SMESH_MesherHelper &helper,
+    int &Netgen_NbOfNodes);
+
+  bool computePrepareParam(
+    SMESH_Mesh&         aMesh,
+    NETGENPlugin_NetgenLibWrapper &ngLib,
+    netgen::OCCGeometry &occgeo,
+    SMESH_MesherHelper &helper,
+    int &endWith);
+
+  bool computeRunMesher(
+    netgen::OCCGeometry &occgeo,
+    std::vector< const SMDS_MeshNode* > &nodeVec,
+    netgen::Mesh* ngMesh,
+    NETGENPlugin_NetgenLibWrapper &ngLib,
+    int &startWith, int &endWith);
+
+  bool computeFillMesh(
+    std::vector< const SMDS_MeshNode* > &nodeVec,
+    NETGENPlugin_NetgenLibWrapper &ngLib,
+    SMESH_MesherHelper &helper,
+    int &Netgen_NbOfNodes);
+
  protected:
 
+  virtual bool getSurfaceElements(
+    SMESH_Mesh&         aMesh,
+    const TopoDS_Shape& aShape,
+    SMESH_ProxyMesh::Ptr proxyMesh,
+    NETGENPlugin_Internals &internals,
+    SMESH_MesherHelper &helper,
+    std::map<const SMDS_MeshElement*, std::tuple<bool, bool>, TIDCompare>& listElements);
+
   bool compute(SMESH_Mesh&                          mesh,
                SMESH_MesherHelper&                  helper,
                std::vector< const SMDS_MeshNode* >& nodeVec,

src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote.cxx

@@ -0,0 +1,406 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : NETGENPlugin_NETGEN_3D_Remote.cxx
+// Created   : lundi 19 Septembre 2022
+// Author    : Yoann AUDOUIN (CEA)
+// Project   : SALOME
+//=============================================================================
+//
+//
+#include "NETGENPlugin_NETGEN_3D_Remote.hxx"
+
+#include "NETGENPlugin_NETGEN_3D.hxx"
+
+#include "NETGENPlugin_DriverParam.hxx"
+#include "NETGENPlugin_Hypothesis.hxx"
+
+#include "Utils_SALOME_Exception.hxx"
+
+#include <SMESH_Gen.hxx>
+#include <SMESH_Mesh.hxx>
+#include <SMESH_ParallelMesh.hxx>
+#include <SMESH_MesherHelper.hxx>
+#include <SMESH_DriverShape.hxx>
+#include <SMESH_DriverMesh.hxx>
+#include <SMESHDS_Mesh.hxx>
+#include <SMESH_MeshLocker.hxx>
+
+#include <QString>
+#include <QProcess>
+
+#include <boost/filesystem.hpp>
+namespace fs = boost::filesystem;
+/*
+  Netgen include files
+*/
+
+#ifndef OCCGEOMETRY
+#define OCCGEOMETRY
+#endif
+#include <occgeom.hpp>
+
+#ifdef NETGEN_V5
+#include <ngexception.hpp>
+#endif
+#ifdef NETGEN_V6
+#include <core/exception.hpp>
+#endif
+
+namespace nglib {
+#include <nglib.h>
+}
+namespace netgen {
+
+  NETGENPLUGIN_DLL_HEADER
+  extern MeshingParameters mparam;
+
+  NETGENPLUGIN_DLL_HEADER
+  extern volatile multithreadt multithread;
+}
+using namespace nglib;
+
+//=============================================================================
+/*!
+ * Constructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D_Remote::NETGENPlugin_NETGEN_3D_Remote(int hypId, SMESH_Gen * gen)
+  : NETGENPlugin_NETGEN_3D(hypId, gen)
+{
+  _name = "NETGEN_3D_Remote";
+}
+
+//=============================================================================
+/*!
+ * Destructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D_Remote::~NETGENPlugin_NETGEN_3D_Remote()
+{
+}
+
+/**
+ * @brief Fill the structure netgen_param with the information from the hypothesis
+ *
+ * @param hyp the hypothesis
+ * @param aParams the netgen_param structure
+ */
+void NETGENPlugin_NETGEN_3D_Remote::fillParameters(const NETGENPlugin_Hypothesis* hyp, netgen_params &aParams)
+{
+  aParams.myType             = hypoType::Hypo;
+  aParams.maxh               = hyp->GetMaxSize();
+  aParams.minh               = hyp->GetMinSize();
+  aParams.segmentsperedge    = hyp->GetNbSegPerEdge();
+  aParams.grading            = hyp->GetGrowthRate();
+  aParams.curvaturesafety    = hyp->GetNbSegPerRadius();
+  aParams.secondorder        = hyp->GetSecondOrder() ? 1 : 0;
+  aParams.quad               = hyp->GetQuadAllowed() ? 1 : 0;
+  aParams.optimize           = hyp->GetOptimize();
+  aParams.fineness           = hyp->GetFineness();
+  aParams.uselocalh          = hyp->GetSurfaceCurvature();
+  aParams.merge_solids       = hyp->GetFuseEdges();
+  aParams.chordalError       = hyp->GetChordalErrorEnabled() ? hyp->GetChordalError() : -1.;
+  aParams.optsteps2d         = aParams.optimize ? hyp->GetNbSurfOptSteps() : 0;
+  aParams.optsteps3d         = aParams.optimize ? hyp->GetNbVolOptSteps()  : 0;
+  aParams.elsizeweight       = hyp->GetElemSizeWeight();
+  aParams.opterrpow          = hyp->GetWorstElemMeasure();
+  aParams.delaunay           = hyp->GetUseDelauney();
+  aParams.checkoverlap       = hyp->GetCheckOverlapping();
+  aParams.checkchartboundary = hyp->GetCheckChartBoundary();
+#ifdef NETGEN_V6
+  // std::string
+  aParams.meshsizefilename = hyp->GetMeshSizeFile();
+  aParams.closeedgefac = 2;
+  aParams.nbThreads = hyp->GetNbThreads();
+#else
+  // const char*
+  aParams.meshsizefilename = hyp->GetMeshSizeFile();
+  aParams.closeedgefac = 0;
+  aParams.nbThreads = 0;
+#endif
+}
+
+//
+
+/**
+ * @brief write in a binary file the orientation for each surface element of the mesh
+ *
+ * @param aMesh The mesh
+ * @param aShape the shape associated to the mesh
+ * @param output_file name of the binary file
+ */
+void NETGENPlugin_NETGEN_3D_Remote::exportElementOrientation(SMESH_Mesh& aMesh,
+                                                      const TopoDS_Shape& aShape,
+                                                      const std::string output_file)
+{
+  SMESH_MesherHelper helper(aMesh);
+  NETGENPlugin_Internals internals( aMesh, aShape, /*is3D=*/true );
+  SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( aMesh ));
+  std::map<vtkIdType, bool> elemOrientation;
+
+  for ( TopExp_Explorer exFa( aShape, TopAbs_FACE ); exFa.More(); exFa.Next())
+  {
+    const TopoDS_Shape& aShapeFace = exFa.Current();
+    int faceID = aMesh.GetMeshDS()->ShapeToIndex( aShapeFace );
+    bool isInternalFace = internals.isInternalShape( faceID );
+    bool isRev = false;
+    if ( !isInternalFace &&
+          helper.NbAncestors(aShapeFace, aMesh, aShape.ShapeType()) > 1 )
+      // IsReversedSubMesh() can work wrong on strongly curved faces,
+      // so we use it as less as possible
+      isRev = helper.IsReversedSubMesh( TopoDS::Face( aShapeFace ));
+
+    const SMESHDS_SubMesh * aSubMeshDSFace = proxyMesh->GetSubMesh( aShapeFace );
+    if ( !aSubMeshDSFace ) continue;
+
+    SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
+    if ( _quadraticMesh &&
+          dynamic_cast< const SMESH_ProxyMesh::SubMesh*>( aSubMeshDSFace ))
+    {
+      // add medium nodes of proxy triangles to helper (#16843)
+      while ( iteratorElem->more() )
+        helper.AddTLinks( static_cast< const SMDS_MeshFace* >( iteratorElem->next() ));
+
+      iteratorElem = aSubMeshDSFace->GetElements();
+    }
+    while ( iteratorElem->more() ) // loop on elements on a geom face
+    {
+      // check mesh face
+      const SMDS_MeshElement* elem = iteratorElem->next();
+      if ( !elem )
+        error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
+      if ( elem->NbCornerNodes() != 3 )
+        error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
+      elemOrientation[elem->GetID()] = isRev;
+    } // loop on elements on a face
+  } // loop on faces of a SOLID or SHELL
+
+  {
+    std::ofstream df(output_file, ios::out|ios::binary);
+    int size=elemOrientation.size();
+
+    df.write((char*)&size, sizeof(int));
+    for(auto const& [id, orient]:elemOrientation){
+      df.write((char*)&id, sizeof(vtkIdType));
+      df.write((char*)&orient, sizeof(bool));
+    }
+  }
+}
+
+/**
+ * @brief Compute mesh associate to shape
+ *
+ * @param aMesh The mesh
+ * @param aShape The shape
+ * @return true fi there are some error
+ */
+bool NETGENPlugin_NETGEN_3D_Remote::Compute(SMESH_Mesh&         aMesh,
+                                           const TopoDS_Shape& aShape)
+{
+  {
+    SMESH_MeshLocker myLocker(&aMesh);
+    SMESH_Hypothesis::Hypothesis_Status hypStatus;
+    NETGENPlugin_NETGEN_3D::CheckHypothesis(aMesh, aShape, hypStatus);
+  }
+  SMESH_ParallelMesh& aParMesh = dynamic_cast<SMESH_ParallelMesh&>(aMesh);
+
+  // Temporary folder for run
+#ifdef WIN32
+  fs::path tmp_folder = aParMesh.GetTmpFolder() / fs::path("Volume-%%%%-%%%%");
+#else
+  fs::path tmp_folder = aParMesh.GetTmpFolder() / fs::unique_path(fs::path("Volume-%%%%-%%%%"));
+#endif
+  fs::create_directories(tmp_folder);
+  // Using MESH2D generated after all triangles where created.
+  fs::path mesh_file=aParMesh.GetTmpFolder() / fs::path("Mesh2D.med");
+  fs::path element_orientation_file=tmp_folder / fs::path("element_orientation.dat");
+  fs::path new_element_file=tmp_folder / fs::path("new_elements.dat");
+  fs::path tmp_mesh_file=tmp_folder / fs::path("tmp_mesh.med");
+  // Not used kept for debug
+  //fs::path output_mesh_file=tmp_folder / fs::path("output_mesh.med");
+  fs::path shape_file=tmp_folder / fs::path("shape.brep");
+  fs::path param_file=tmp_folder / fs::path("netgen3d_param.txt");
+  fs::path log_file=tmp_folder / fs::path("run.log");
+  fs::path cmd_file=tmp_folder / fs::path("cmd.txt");
+  // TODO: See if we can retreived name from aMesh ?
+  std::string mesh_name = "MESH";
+
+  {
+    SMESH_MeshLocker myLocker(&aMesh);
+    //Writing Shape
+    SMESH_DriverShape::exportShape(shape_file.string(), aShape);
+
+    //Writing hypo
+    netgen_params aParams;
+    fillParameters(_hypParameters, aParams);
+
+    exportNetgenParams(param_file.string(), aParams);
+
+    // Exporting element orientation
+    exportElementOrientation(aMesh, aShape, element_orientation_file.string());
+  }
+
+  // Calling run_mesher
+  // Path to mesher script
+  fs::path mesher_launcher = fs::path(std::getenv("SMESH_ROOT_DIR"))/
+       fs::path("bin")/
+       fs::path("salome")/
+       fs::path("mesher_launcher.py");
+
+
+  std::string s_program="python3";
+  std::list<std::string> params;
+  params.push_back(mesher_launcher.string());
+  params.push_back("NETGEN3D");
+  params.push_back(mesh_file.string());
+  params.push_back(shape_file.string());
+  params.push_back(param_file.string());
+  params.push_back("--elem-orient-file=" + element_orientation_file.string());
+  params.push_back("--new-element-file=" + new_element_file.string());
+
+  // Parallelism method parameters
+  int method = aParMesh.GetParallelismMethod();
+  if(method == ParallelismMethod::MultiThread){
+    params.push_back("--method=local");
+  } else if (method == ParallelismMethod::MultiNode){
+    params.push_back("--method=cluster");
+    params.push_back("--resource="+aParMesh.GetResource());
+    params.push_back("--wc-key="+aParMesh.GetWcKey());
+    params.push_back("--nb-proc=1");
+    params.push_back("--nb-proc-per-node="+to_string(aParMesh.GetNbProcPerNode()));
+    params.push_back("--nb-node="+to_string(aParMesh.GetNbNode()));
+    params.push_back("--walltime="+aParMesh.GetWalltime());
+  } else {
+    throw SALOME_Exception("Unknown parallelism method "+method);
+  }
+  std::string cmd = "";
+  cmd += s_program;
+  for(auto arg: params){
+    cmd += " " + arg;
+  }
+  MESSAGE("Running command: ");
+  MESSAGE(cmd);
+  // Writing command in cmd.log
+  {
+    std::ofstream flog(cmd_file.string());
+    flog << cmd << endl;
+  }
+
+  // Building arguments for QProcess
+  QString program = QString::fromStdString(s_program);
+  QStringList arguments;
+  for(auto arg : params){
+    arguments << arg.c_str();
+  }
+
+  QString out_file = log_file.string().c_str();
+  QProcess myProcess;
+  myProcess.setProcessChannelMode(QProcess::MergedChannels);
+  myProcess.setStandardOutputFile(out_file);
+
+  myProcess.start(program, arguments);
+  // Waiting for process to finish (argument -1 make it wait until the end of
+  // the process otherwise it just waits 30 seconds)
+  bool finished = myProcess.waitForFinished(-1);
+  int ret = myProcess.exitCode();
+
+  if(ret != 0 || !finished){
+    // Run crahed
+    std::string msg = "Issue with mesh_launcher: \n";
+    msg += "See log for more details: " + log_file.string() + "\n";
+    msg += cmd + "\n";
+    throw SALOME_Exception(msg);
+  }
+
+  {
+    SMESH_MeshLocker myLocker(&aMesh);
+    std::ifstream df(new_element_file.string(), ios::binary);
+
+    int Netgen_NbOfNodes;
+    int Netgen_NbOfNodesNew;
+    int Netgen_NbOfTetra;
+    double Netgen_point[3];
+    int    Netgen_tetrahedron[4];
+    int nodeID;
+
+    SMESH_MesherHelper helper(aMesh);
+    // This function is mandatory for setElementsOnShape to work
+    helper.IsQuadraticSubMesh(aShape);
+    helper.SetElementsOnShape( true );
+
+    // Number of nodes in intial mesh
+    df.read((char*) &Netgen_NbOfNodes, sizeof(int));
+    // Number of nodes added by netgen
+    df.read((char*) &Netgen_NbOfNodesNew, sizeof(int));
+
+    // Filling nodevec (correspondence netgen numbering mesh numbering)
+    vector< const SMDS_MeshNode* > nodeVec ( Netgen_NbOfNodesNew + 1 );
+    //vector<int> nodeTmpVec ( Netgen_NbOfNodesNew + 1 );
+    SMESHDS_Mesh * meshDS = helper.GetMeshDS();
+    for (int nodeIndex = 1 ; nodeIndex <= Netgen_NbOfNodes; ++nodeIndex )
+    {
+      //Id of the point
+      df.read((char*) &nodeID, sizeof(int));
+      nodeVec.at(nodeIndex) = meshDS->FindNode(nodeID);
+    }
+
+    // Add new points and update nodeVec
+    for (int nodeIndex = Netgen_NbOfNodes +1 ; nodeIndex <= Netgen_NbOfNodesNew; ++nodeIndex )
+    {
+      df.read((char *) &Netgen_point, sizeof(double)*3);
+
+      nodeVec.at(nodeIndex) = helper.AddNode(Netgen_point[0],
+                                 Netgen_point[1],
+                                 Netgen_point[2]);
+    }
+
+    // Add tetrahedrons
+    df.read((char*) &Netgen_NbOfTetra, sizeof(int));
+
+    for ( int elemIndex = 1; elemIndex <= Netgen_NbOfTetra; ++elemIndex )
+    {
+      df.read((char*) &Netgen_tetrahedron, sizeof(int)*4);
+      helper.AddVolume(
+                    nodeVec.at( Netgen_tetrahedron[0] ),
+                    nodeVec.at( Netgen_tetrahedron[1] ),
+                    nodeVec.at( Netgen_tetrahedron[2] ),
+                    nodeVec.at( Netgen_tetrahedron[3] ));
+    }
+  }
+
+  return true;
+}
+
+/**
+ * @brief Assign submeshes to compute
+ *
+ * @param aSubMesh submesh to add
+ */
+void NETGENPlugin_NETGEN_3D_Remote::setSubMeshesToCompute(SMESH_subMesh * aSubMesh)
+{
+  SMESH_MeshLocker myLocker(aSubMesh->GetFather());
+  SMESH_Algo::setSubMeshesToCompute(aSubMesh);
+}

src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote.hxx

@@ -0,0 +1,75 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : NETGENPlugin_NETGEN_3D_Remote.hxx
+// Created   : lundi 19 Septembre 2022
+// Author    : Yoann AUDOUIN (EDF)
+// Project   : SALOME
+//=============================================================================
+//
+#ifndef _NETGENPlugin_NETGEN_3D_REMOTE_HXX_
+#define _NETGENPlugin_NETGEN_3D_REMOTE_HXX_
+
+#include "NETGENPlugin_NETGEN_3D.hxx"
+
+#include <vector>
+#include <map>
+
+class StdMeshers_ViscousLayers;
+class StdMeshers_MaxElementVolume;
+class NETGENPlugin_Hypothesis;
+class NETGENPlugin_NetgenLibWrapper;
+class netgen_params;
+class SMDS_MeshNode;
+
+using namespace std;
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D_Remote: public NETGENPlugin_NETGEN_3D
+{
+ public:
+  NETGENPlugin_NETGEN_3D_Remote(int hypId, SMESH_Gen* gen);
+  virtual ~NETGENPlugin_NETGEN_3D_Remote();
+
+  // Function whould not be used with remote Computing
+  bool CheckHypothesis (SMESH_Mesh&         aMesh,
+                        const TopoDS_Shape& aShape,
+                        Hypothesis_Status&  aStatus) override {(void)aMesh;(void)aShape;aStatus = HYP_OK;return true;};
+
+  bool Compute(SMESH_Mesh&         aMesh,
+              const TopoDS_Shape& aShape) override;
+
+  void setSubMeshesToCompute(SMESH_subMesh * aSubMesh) override;
+
+
+ protected:
+  void exportElementOrientation(SMESH_Mesh& aMesh,
+                                const TopoDS_Shape& aShape,
+                                const std::string output_file);
+
+  void fillParameters(const NETGENPlugin_Hypothesis* hyp,
+                      netgen_params &aParams);
+
+
+};
+
+#endif

src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote_i.cxx

@@ -0,0 +1,80 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  SMESH SMESH_I : idl implementation based on 'SMESH' unit's classes
+//  File   : NETGENPlugin_NETGEN_3D_Remote_i.cxx
+//  Author : Yoann AUDOUIN (EDF)
+//  Module : NETGENPlugin
+//  $Header$
+//
+#include "NETGENPlugin_NETGEN_3D_Remote_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+using namespace std;
+
+//=============================================================================
+/*!
+ *  NETGENPlugin_NETGEN_3D_Remote_i::NETGENPlugin_NETGEN_3D_Remote_i
+ *
+ *  Constructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D_Remote_i::NETGENPlugin_NETGEN_3D_Remote_i( PortableServer::POA_ptr thePOA,
+                                                    ::SMESH_Gen*            theGenImpl )
+     : SALOME::GenericObj_i( thePOA ),
+       SMESH_Hypothesis_i( thePOA ),
+       SMESH_Algo_i( thePOA ),
+       SMESH_3D_Algo_i( thePOA )
+{
+  myBaseImpl = new ::NETGENPlugin_NETGEN_3D_Remote( theGenImpl->GetANewId(),
+                                             theGenImpl );
+}
+
+//=============================================================================
+/*!
+ *  NETGENPlugin_NETGEN_3D_Remote_i::~NETGENPlugin_NETGEN_3D_Remote_i
+ *
+ *  Destructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D_Remote_i::~NETGENPlugin_NETGEN_3D_Remote_i()
+{
+}
+
+//=============================================================================
+/*!
+ *  NETGENPlugin_NETGEN_3D_Remote_i::GetImpl
+ *
+ *  Get implementation
+ */
+//=============================================================================
+
+::NETGENPlugin_NETGEN_3D_Remote* NETGENPlugin_NETGEN_3D_Remote_i::GetImpl()
+{
+  return ( ::NETGENPlugin_NETGEN_3D_Remote* )myBaseImpl;
+}
+

src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote_i.hxx

@@ -0,0 +1,58 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  SMESH SMESH_I : idl implementation based on 'SMESH' unit's classes
+//  File   : NETGENPlugin_NETGEN_3D_Remote_i.hxx
+//  Author : Yoann AUDOUIN (EDF)
+//  Module : NETGENPlugin
+//  $Header$
+//
+#ifndef _NETGENPlugin_NETGEN_3D_REMOTE_I_HXX_
+#define _NETGENPlugin_NETGEN_3D_REMOTE_I_HXX_
+
+#include "NETGENPlugin_Defs.hxx"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(NETGENPlugin_Algorithm)
+
+#include "SMESH_3D_Algo_i.hxx"
+#include "NETGENPlugin_NETGEN_3D_Remote.hxx"
+
+// ======================================================
+// NETGEN 3d algorithm
+// ======================================================
+class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D_Remote_i:
+  public virtual POA_NETGENPlugin::NETGENPlugin_NETGEN_3D_Remote,
+  public virtual SMESH_3D_Algo_i
+{
+public:
+  // Constructor
+  NETGENPlugin_NETGEN_3D_Remote_i( PortableServer::POA_ptr thePOA,
+                            ::SMESH_Gen*            theGenImpl );
+  // Destructor
+  virtual ~NETGENPlugin_NETGEN_3D_Remote_i();
+
+  // Get implementation
+  ::NETGENPlugin_NETGEN_3D_Remote* GetImpl();
+};
+
+#endif

src/NETGENPlugin/NETGENPlugin_NETGEN_3D_SA.cxx

@@ -0,0 +1,400 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : NETGENPlugin_NETGEN_3D_SA.cxx
+// Created   : lundi 19 Septembre 2022
+// Author    : Yoann AUDOUIN (CEA)
+// Project   : SALOME
+//=============================================================================
+//
+//
+#include "NETGENPlugin_NETGEN_3D_SA.hxx"
+
+#include "NETGENPlugin_DriverParam.hxx"
+#include "NETGENPlugin_Hypothesis.hxx"
+#include "StdMeshers_MaxElementVolume.hxx"
+
+#include <SMESH_Gen.hxx>
+#include <SMESH_Mesh.hxx>
+#include <SMESH_MesherHelper.hxx>
+#include <SMESH_DriverShape.hxx>
+#include <SMESH_DriverMesh.hxx>
+#include <SMESHDS_Mesh.hxx>
+
+
+#ifdef WIN32
+#include <filesystem>
+namespace fs = std::filesystem;
+#else
+#include <boost/filesystem.hpp>
+namespace fs = boost::filesystem;
+#endif
+
+/*
+  Netgen include files
+*/
+
+#ifndef OCCGEOMETRY
+#define OCCGEOMETRY
+#endif
+#include <occgeom.hpp>
+
+#ifdef NETGEN_V5
+#include <ngexception.hpp>
+#endif
+#ifdef NETGEN_V6
+#include <core/exception.hpp>
+#endif
+
+namespace nglib {
+#include <nglib.h>
+}
+namespace netgen {
+
+  NETGENPLUGIN_DLL_HEADER
+  extern MeshingParameters mparam;
+
+  NETGENPLUGIN_DLL_HEADER
+  extern volatile multithreadt multithread;
+}
+using namespace nglib;
+
+//=============================================================================
+/*!
+ * Constructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D_SA::NETGENPlugin_NETGEN_3D_SA()
+  :  NETGENPlugin_NETGEN_3D(0, new SMESH_Gen())
+{
+  _name = "NETGEN_3D_SA";
+}
+
+//=============================================================================
+/*!
+ * Destructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D_SA::~NETGENPlugin_NETGEN_3D_SA()
+{
+  if(_gen)
+    delete _gen;
+}
+
+/**
+ * @brief fill plugin hypothesis from the netgen_params structure
+ *
+ * @param aParams the structure
+ * @param gen SMESH_Gen associate with the SA
+ */
+void NETGENPlugin_NETGEN_3D_SA::fillHyp(netgen_params aParams)
+{
+  if(aParams.has_netgen_param){
+    NETGENPlugin_Hypothesis * hypParameters = new NETGENPlugin_Hypothesis(0, GetGen());
+
+    hypParameters->SetMaxSize(aParams.maxh);
+    hypParameters->SetMinSize(aParams.minh);
+    hypParameters->SetNbSegPerEdge(aParams.segmentsperedge);
+    hypParameters->SetGrowthRate(aParams.grading);
+    hypParameters->SetNbSegPerRadius(aParams.curvaturesafety);
+    hypParameters->SetSecondOrder(aParams.secondorder);
+    hypParameters->SetQuadAllowed(aParams.quad);
+    hypParameters->SetOptimize(aParams.optimize);
+    hypParameters->SetFineness((NETGENPlugin_Hypothesis::Fineness)aParams.fineness);
+    hypParameters->SetSurfaceCurvature(aParams.uselocalh);
+    hypParameters->SetFuseEdges(aParams.merge_solids);
+    hypParameters->SetChordalErrorEnabled(aParams.chordalError);
+    if(aParams.optimize){
+      hypParameters->SetNbSurfOptSteps(aParams.optsteps2d);
+      hypParameters->SetNbVolOptSteps(aParams.optsteps3d);
+    }
+    hypParameters->SetElemSizeWeight(aParams.elsizeweight);
+    hypParameters->SetWorstElemMeasure(aParams.opterrpow);
+    hypParameters->SetUseDelauney(aParams.delaunay);
+    hypParameters->SetCheckOverlapping(aParams.checkoverlap);
+    hypParameters->SetCheckChartBoundary(aParams.checkchartboundary);
+    hypParameters->SetMeshSizeFile(aParams.meshsizefilename);
+
+    _hypParameters = dynamic_cast< const NETGENPlugin_Hypothesis *> (hypParameters);
+  }
+  if(aParams.has_maxelementvolume_hyp){
+    _hypMaxElementVolume = new StdMeshers_MaxElementVolume(1, GetGen());
+    _maxElementVolume = aParams.maxElementVolume;
+  }
+  // TODO: Handle viscous layer
+}
+
+/**
+ * @brief Write a binary file containing information on the elements/nodes
+ *        created by the mesher
+ *
+ * @param nodeVec mapping between the mesh id and the netgen structure id
+ * @param ngLib Wrapper on netgen library
+ * @param new_element_file Name of the output file
+ * @param Netgen_NbOfNodes Number of nodes in the netgen structure
+ * @return true if there are some error
+ */
+bool NETGENPlugin_NETGEN_3D_SA::computeFillNewElementFile(
+    std::vector< const SMDS_MeshNode* > &nodeVec,
+    NETGENPlugin_NetgenLibWrapper &ngLib,
+    std::string new_element_file,
+    int &Netgen_NbOfNodes
+)
+{
+  MESSAGE("Writting new elements")
+  Ng_Mesh* Netgen_mesh = ngLib.ngMesh();
+
+  int Netgen_NbOfNodesNew = Ng_GetNP(Netgen_mesh);
+  int Netgen_NbOfTetra    = Ng_GetNE(Netgen_mesh);
+  bool isOK = ( Netgen_NbOfTetra > 0 );
+  if ( isOK && !new_element_file.empty() )
+  {
+    std::ofstream df(new_element_file, ios::out|ios::binary);
+
+    double Netgen_point[3];
+    int    Netgen_tetrahedron[4];
+
+    // Writing nodevec (correspondence netgen numbering mesh numbering)
+    // Number of nodes
+    df.write((char*) &Netgen_NbOfNodes, sizeof(int));
+    df.write((char*) &Netgen_NbOfNodesNew, sizeof(int));
+    for (int nodeIndex = 1 ; nodeIndex <= Netgen_NbOfNodes; ++nodeIndex )
+    {
+      //Id of the point
+      int id = nodeVec.at(nodeIndex)->GetID();
+      df.write((char*) &id, sizeof(int));
+    }
+
+    // Writing info on new points
+    for (int nodeIndex = Netgen_NbOfNodes +1 ; nodeIndex <= Netgen_NbOfNodesNew; ++nodeIndex )
+    {
+      Ng_GetPoint(Netgen_mesh, nodeIndex, Netgen_point );
+      // Coordinates of the point
+      df.write((char *) &Netgen_point, sizeof(double)*3);
+    }
+
+    // create tetrahedrons
+    df.write((char*) &Netgen_NbOfTetra, sizeof(int));
+    for ( int elemIndex = 1; elemIndex <= Netgen_NbOfTetra; ++elemIndex )
+    {
+      Ng_GetVolumeElement(Netgen_mesh, elemIndex, Netgen_tetrahedron);
+      df.write((char*) &Netgen_tetrahedron, sizeof(int)*4);
+    }
+  }
+  return false;
+}
+
+/**
+ * @brief Compute mesh associated to shape
+ *
+ * @param aShape the shape
+ * @param aMesh the mesh
+ * @param aParams netgen_params structure
+ * @param new_element_file Name of the file containing new element
+ * @param output_mesh Name of the output mesh (if empty it will not be written)
+ * @return true if there are some error
+ */
+bool NETGENPlugin_NETGEN_3D_SA::Compute(
+        TopoDS_Shape &aShape,
+        SMESH_Mesh& aMesh,
+        netgen_params& aParams,
+        std::string new_element_file,
+        bool output_mesh)
+{
+  MESSAGE("Compute");
+  // vector of nodes in which node index == netgen ID
+  vector< const SMDS_MeshNode* > nodeVec;
+  NETGENPlugin_NetgenLibWrapper ngLib;
+  SMESH_MesherHelper helper(aMesh);
+  int startWith = netgen::MESHCONST_MESHVOLUME;
+  int endWith   = netgen::MESHCONST_OPTVOLUME;
+  int Netgen_NbOfNodes=0;
+
+  // Changing netgen log_file putting it next to new_element_file
+  fs::path netgen_log_file = fs::path(new_element_file).remove_filename() / fs::path("NETGEN.out");
+  MESSAGE("netgen ouput"<<netgen_log_file.string());
+
+  ngLib.setOutputFile(netgen_log_file.string());
+
+  NETGENPlugin_NETGEN_3D::computeFillNgMesh(aMesh, aShape, nodeVec, ngLib, helper, Netgen_NbOfNodes);
+
+  netgen::OCCGeometry occgeo;
+  NETGENPlugin_NETGEN_3D::computePrepareParam(aMesh, ngLib, occgeo, helper, endWith);
+
+  NETGENPlugin_NETGEN_3D::computeRunMesher(occgeo, nodeVec, ngLib._ngMesh, ngLib, startWith, endWith);
+
+  computeFillNewElementFile(nodeVec, ngLib, new_element_file, Netgen_NbOfNodes);
+
+  if(output_mesh)
+    NETGENPlugin_NETGEN_3D::computeFillMesh(nodeVec, ngLib, helper, Netgen_NbOfNodes);
+
+  return false;
+}
+
+
+/**
+ * @brief Running the mesher on the given files
+ *
+ * @param input_mesh_file Mesh file (containing 2D elements)
+ * @param shape_file Shape file (BREP or STEP format)
+ * @param hypo_file Ascii file containing the netgen parameters
+ * @param element_orientation_file Binary file containing the orientation of surface elemnts
+ * @param new_element_file output file containing info the elements created by the mesher
+ * @param output_mesh_file output mesh file (if empty it will not be created)
+ * @return int
+ */
+int NETGENPlugin_NETGEN_3D_SA::run(const std::string input_mesh_file,
+          const std::string shape_file,
+          const std::string hypo_file,
+          const std::string element_orientation_file,
+          const std::string new_element_file,
+          const std::string output_mesh_file)
+{
+
+  _element_orientation_file = element_orientation_file;
+
+  std::unique_ptr<SMESH_Mesh> myMesh(_gen->CreateMesh(false));
+
+  SMESH_DriverMesh::importMesh(input_mesh_file, *myMesh);
+
+  // Importing shape
+  TopoDS_Shape myShape;
+  SMESH_DriverShape::importShape(shape_file, myShape);
+
+  // Importing hypothesis
+  netgen_params myParams;
+
+  importNetgenParams(hypo_file, myParams);
+  fillHyp(myParams);
+  MESSAGE("Meshing with netgen3d");
+  int ret = Compute(myShape, *myMesh, myParams,
+                      new_element_file,
+                      !output_mesh_file.empty());
+
+
+  if(ret){
+    std::cerr << "Meshing failed" << std::endl;
+    return ret;
+  }
+
+  if(!output_mesh_file.empty()){
+    std::string meshName = "MESH";
+    SMESH_DriverMesh::exportMesh(output_mesh_file, *myMesh, meshName);
+  }
+
+  return ret;
+}
+
+/**
+ * @brief Compute the list of already meshed Surface elements and info
+ *        on their orientation and if they are internal
+ *
+ * @param aMesh Global Mesh
+ * @param aShape Shape associated to the mesh
+ * @param proxyMesh pointer to mesh used fo find the elements
+ * @param internals information on internal sub shapes
+ * @param helper helper associated to the mesh
+ * @param listElements map of surface element associated with
+ *                     their orientation and internal status
+ * @return true if their was some error
+ */
+bool NETGENPlugin_NETGEN_3D_SA::getSurfaceElements(
+    SMESH_Mesh&         aMesh,
+    const TopoDS_Shape& aShape,
+    SMESH_ProxyMesh::Ptr proxyMesh,
+    NETGENPlugin_Internals &internals,
+    SMESH_MesherHelper &helper,
+    std::map<const SMDS_MeshElement*, tuple<bool, bool>, TIDCompare>& listElements
+    )
+{
+  // To remove compilation warnings
+  (void) aShape;
+  (void) proxyMesh;
+  (void) internals;
+  (void) helper;
+  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+
+  // Get list of elements + their orientation from element_orientation file
+  std::map<vtkIdType, bool> elemOrientation;
+  {
+    // Setting all element orientation to false if there no element orientation file
+    if(_element_orientation_file.empty()){
+      MESSAGE("No element orientation file");
+
+      SMDS_ElemIteratorPtr iteratorElem = meshDS->elementsIterator(SMDSAbs_Face);
+      while ( iteratorElem->more() ) // loop on elements on a geom face
+        {
+          // check mesh face
+          const SMDS_MeshElement* elem = iteratorElem->next();
+          elemOrientation[elem->GetID()] = false;
+        }
+    } else {
+      MESSAGE("Reading from elements from file: " << _element_orientation_file);
+      std::ifstream df(_element_orientation_file, ios::binary|ios::in);
+      int nbElement;
+      bool orient;
+
+      // Warning of the use of vtkIdType (I had issue when run_mesher was compiled with internal vtk) and salome not
+      // Sizeof was the same but how he othered the type was different
+      // Maybe using another type (uint64_t) instead would be better
+      vtkIdType id;
+      df.read((char*)&nbElement, sizeof(int));
+
+      for(int ielem=0;ielem<nbElement;++ielem){
+        df.read((char*) &id, sizeof(vtkIdType));
+        df.read((char*) &orient, sizeof(bool));
+        elemOrientation[id] = orient;
+      }
+    }
+  }
+
+  // Adding elements from Mesh
+  SMDS_ElemIteratorPtr iteratorElem = meshDS->elementsIterator(SMDSAbs_Face);
+  bool isRev;
+
+  bool isIn;
+
+  while ( iteratorElem->more() ) // loop on elements on a geom face
+  {
+    // check mesh face
+    const SMDS_MeshElement* elem = iteratorElem->next();
+    if ( !elem ){
+      return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
+    }
+    if ( elem->NbCornerNodes() != 3 ){
+      return error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
+    }
+    // Keeping only element that are in the element orientation file
+    isIn = elemOrientation.count(elem->GetID())==1;
+    if(!isIn)
+      continue;
+    // Get orientation
+    // Netgen requires that all the triangle point outside
+    isRev = elemOrientation[elem->GetID()];
+    listElements[elem] = tuple<bool, bool>(isRev, false);
+  }
+
+  return false;
+}

src/NETGENPlugin/NETGENPlugin_NETGEN_3D_SA.hxx

@@ -0,0 +1,81 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File      : NETGENPlugin_NETGEN_3D_SA.hxx
+// Created   : lundi 19 Septembre 2022
+// Author    : Yoann AUDOUIN (EDF)
+// Project   : SALOME
+//=============================================================================
+//
+#ifndef _NETGENPlugin_NETGEN_3D_SA_HXX_
+#define _NETGENPlugin_NETGEN_3D_SA_HXX_
+
+#include "NETGENPlugin_NETGEN_3D.hxx"
+
+#include <vector>
+#include <map>
+
+class NETGENPlugin_NetgenLibWrapper;
+class netgen_params;
+class SMDS_MeshNode;
+
+using namespace std;
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D_SA: public NETGENPlugin_NETGEN_3D
+{
+ public:
+  NETGENPlugin_NETGEN_3D_SA();
+  virtual ~NETGENPlugin_NETGEN_3D_SA();
+
+  void fillHyp(netgen_params aParams);
+  bool Compute(TopoDS_Shape &aShape, SMESH_Mesh& aMesh, netgen_params& aParams,
+                       std::string new_element_file, bool output_mesh);
+
+  int run(const std::string input_mesh_file,
+          const std::string shape_file,
+          const std::string hypo_file,
+          const std::string element_orientation_file,
+          const std::string new_element_file,
+          const std::string output_mesh_file);
+
+ protected:
+
+  bool computeFillNewElementFile(
+    std::vector< const SMDS_MeshNode* > &nodeVec,
+    NETGENPlugin_NetgenLibWrapper &ngLib,
+    std::string new_element_file,
+    int &Netgen_NbOfNodes);
+
+  bool getSurfaceElements(
+    SMESH_Mesh&         aMesh,
+    const TopoDS_Shape& aShape,
+    SMESH_ProxyMesh::Ptr proxyMesh,
+    NETGENPlugin_Internals &internals,
+    SMESH_MesherHelper &helper,
+    std::map<const SMDS_MeshElement*, tuple<bool, bool>, TIDCompare>& listElements
+    ) override;
+
+   std::string _element_orientation_file="";
+};
+
+#endif

src/NETGENPlugin/NETGENPlugin_NETGEN_3D_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_NETGEN_3D_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Remesher_2D.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Remesher_2D.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

src/NETGENPlugin/NETGENPlugin_Runner_main.cxx

@@ -0,0 +1,125 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//  File   : NETGENplugin_Runnner_main.cxx
+//  Author : Yoann AUDOUIN, EDF
+//  Module : NETGEN
+//
+
+#include "NETGENPlugin_NETGEN_2D_SA.hxx"
+#include "NETGENPlugin_NETGEN_3D_SA.hxx"
+#include "NETGENPlugin_NETGEN_1D2D3D_SA.hxx"
+
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <chrono>
+
+/**
+ * @brief Main function
+ *
+ * @param argc Number of arguments
+ * @param argv Arguments
+ *
+ * @return error code
+ */
+int main(int argc, char *argv[]){
+
+  if(argc!=8||(argc==2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help")==0))){
+    std::cout << "Error in number of arguments "<< argc-1<<" given expected 7" <<std::endl;
+    std::cout << "Syntax:"<<std::endl;
+    std::cout << "run_mesher MESHER INPUT_MESH_FILE SHAPE_FILE HYPO_FILE" << std::endl;
+    std::cout << "           ELEM_ORIENT_FILE " << std::endl;
+    std::cout << "           NEW_ELEMENT_FILE OUTPUT_MESH_FILE" << std::endl;
+    std::cout << std::endl;
+    std::cout << " Set argument to NONE to ignore them " << std::endl;
+    std::cout << std::endl;
+    std::cout << "Args:" << std::endl;
+    std::cout << "  MESHER: mesher to use from (NETGEN3D, NETGEN2D)" << std::endl;
+    std::cout << "  INPUT_MESH_FILE: MED File containing lower-dimension-elements already meshed" << std::endl;
+    std::cout << "  SHAPE_FILE: STEP file containing the shape to mesh" << std::endl;
+    std::cout << "  HYPO_FILE: Ascii file containint the list of parameters" << std::endl;
+    std::cout << "  (optional) ELEM_ORIENT_FILE: binary file containing the list of element from INPUT_MESH_FILE associated to the shape and their orientation" << std::endl;
+    std::cout << "  (optional) NEW_ELEMENT_FILE: (out) contains elements and nodes added by the meshing" << std::endl;
+    std::cout << "  (optional) OUTPUT_MESH_FILE: (out) MED File containing the mesh after the run of the mesher" << std::endl;
+    return 1;
+  }
+  std::string mesher=argv[1];
+  std::string input_mesh_file=argv[2];
+  std::string shape_file=argv[3];
+  std::string hypo_file=argv[4];
+  std::string element_orientation_file=argv[5];
+  std::string new_element_file=argv[6];
+  std::string output_mesh_file=argv[7];
+
+  //std::string thing;
+  //std::cin >> thing;
+
+  if (output_mesh_file == "NONE")
+    output_mesh_file = "";
+  if (element_orientation_file == "NONE")
+    element_orientation_file = "";
+  if (new_element_file == "NONE")
+    new_element_file = "";
+  int ret = 0;
+  if (mesher=="NETGEN3D"){
+    NETGENPlugin_NETGEN_3D_SA myplugin;
+    ret = myplugin.run(input_mesh_file,
+             shape_file,
+             hypo_file,
+             element_orientation_file,
+             new_element_file,
+             output_mesh_file );
+  }
+  else if ( mesher=="NETGEN1D" || 
+            mesher=="NETGEN1D2D" || 
+            mesher=="NETGEN1D2D3D" ) 
+  {
+    NETGENPlugin_NETGEN_1D2D3D_SA myplugin;    
+    NETGENPlugin_Mesher::DIM DIM = mesher=="NETGEN1D" ? NETGENPlugin_Mesher::D1 
+                                    : ( mesher=="NETGEN1D2D" ? NETGENPlugin_Mesher::D2 
+                                    : NETGENPlugin_Mesher::D3 );
+
+    ret = myplugin.run(input_mesh_file,
+                  shape_file,
+                  hypo_file,
+                  element_orientation_file,
+                  new_element_file,
+                  output_mesh_file, 
+                  DIM );
+  } 
+  else if ( mesher=="NETGEN2D" ) 
+  {
+    NETGENPlugin_NETGEN_2D_SA myplugin;    
+    ret = myplugin.run(input_mesh_file,
+                  shape_file,
+                  hypo_file,
+                  element_orientation_file,
+                  new_element_file,
+                  output_mesh_file );
+  }  
+  else {
+    std::cerr << "Unknown mesher:" << mesher << std::endl;
+    return 1;
+  }
+  return ret;
+}

src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -61,7 +61,7 @@ NETGENPlugin_SimpleHypothesis_2D::NETGENPlugin_SimpleHypothesis_2D (int
 //=============================================================================
 void NETGENPlugin_SimpleHypothesis_2D::SetNumberOfSegments(int nb)
 {
-  if ( nb < 1 )
+  if ( nb < 0 )
     throw SALOME_Exception("Number of segments must be positive");
   if (nb != _nbSegments)
   {

src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D_i.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public

src/NETGENPlugin/NETGENPlugin_i.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -36,6 +36,8 @@
 #include "NETGENPlugin_NETGEN_2D_ONLY_i.hxx"
 #include "NETGENPlugin_NETGEN_2D_i.hxx"
 #include "NETGENPlugin_NETGEN_3D_i.hxx"
+#include "NETGENPlugin_NETGEN_3D_Remote_i.hxx"
+#include "NETGENPlugin_NETGEN_2D_Remote_i.hxx"
 #include "NETGENPlugin_SimpleHypothesis_2D_i.hxx"
 #include "NETGENPlugin_SimpleHypothesis_3D_i.hxx"
 
@@ -63,6 +65,10 @@ extern "C"
     // Algorithms
     if (strcmp(aHypName, "NETGEN_3D") == 0)
       aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_NETGEN_3D_i>;
+    else if (strcmp(aHypName, "NETGEN_3D_Remote") == 0)
+      aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_NETGEN_3D_Remote_i>;
+    else if (strcmp(aHypName, "NETGEN_2D_Remote") == 0)
+      aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_NETGEN_2D_Remote_i>;      
     else if (strcmp(aHypName, "NETGEN_2D") == 0)
       aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_NETGEN_2D_i>;
     else if (strcmp(aHypName, "NETGEN_2D_ONLY") == 0)

src/NETGENPlugin/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public