Cleanup of NETGEN_2D_Only

cout replaced by MESSAGE + clean up
Removing hard coded meshname from Mesh import
2022-09-28 08:06:51 +02:00 · 2022-09-21 16:36:10 +02:00 · 2022-09-21 15:15:31 +02:00 · 2022-09-21 14:21:30 +02:00 · 2022-09-19 15:13:31 +02:00 · 2022-09-19 11:49:00 +02:00
92 changed files with 1482 additions and 4317 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2012-2021  CEA/DEN, EDF R&D, 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.12.0)
+SALOME_SETUP_VERSION(9.8.0 DEVELOPMENT)
 MESSAGE(STATUS "Building ${PROJECT_NAME_UC} ${${PROJECT_NAME_UC}_VERSION} from \"${${PROJECT_NAME_UC}_GIT_SHA1}\"")
 # Find KERNEL
--- a/340
+++ b/340
@ -0,0 +1,340 @@
 		    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.
--- a/504
+++ b/504
@ -1,504 +0,0 @@
                  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!
--- a/NETGENPLUGIN_version.h.in
+++ b/NETGENPLUGIN_version.h.in
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/12
+++ b/12
@ -14,7 +14,7 @@ module.
 For more information please visit the SALOME platform web site:
-  <https://www.salome-platform.org/>
+  <http://www.salome-platform.org/>
 =======
 License
@ -23,6 +23,10 @@ License
 SALOME platform is distributed under the GNU Lesser General Public License.
 See COPYING file for more details.
 Also, additional information can be found at SALOME platform web site:
  <http://www.salome-platform.org/downloads/license/>
 ============
 Installation
 ============
@ -39,7 +43,11 @@ site:
 * Check Release Notes and Software Requirements of the latest SALOME release at
-  <https://www.salome-platform.org/?page_id=15/>
+  <http://www.salome-platform.org/downloads/current-version/>
 * Pre-requisites page at SALOME web site:
  <http://www.salome-platform.org/downloads/license/>
 Note: SALOME Netgen plug-in needs SALOME KERNEL, SALOME GUI, SALOME Geometry and
 SALOME Mesh as pre-requisites.
--- a/SalomeNETGENPLUGINConfig.cmake.in
+++ b/SalomeNETGENPLUGINConfig.cmake.in
@ -5,7 +5,7 @@
 #
 ###############################################################
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/adm_local/CMakeLists.txt
+++ b/adm_local/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/adm_local/unix/CMakeLists.txt
+++ b/adm_local/unix/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2012-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
--- a/adm_local/unix/config_files/CMakeLists.txt
+++ b/adm_local/unix/config_files/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/adm_local/unix/config_files/check_NETGEN.m4
+++ b/adm_local/unix/config_files/check_NETGEN.m4
@ -1,4 +1,4 @@
-dnl Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+dnl Copyright (C) 2007-2021  CEA/DEN, EDF R&D, 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
--- a/adm_local/unix/config_files/check_NETGENPLUGIN.m4
+++ b/adm_local/unix/config_files/check_NETGENPLUGIN.m4
@ -1,4 +1,4 @@
-dnl Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+dnl Copyright (C) 2007-2021  CEA/DEN, EDF R&D, 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
--- a/bin/CMakeLists.txt
+++ b/bin/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2012-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/doc/salome/CMakeLists.txt
+++ b/doc/salome/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/doc/salome/examples/CMakeLists.txt
+++ b/doc/salome/examples/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2013-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2013-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
--- a/doc/salome/gui/CMakeLists.txt
+++ b/doc/salome/gui/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/doc/salome/gui/NETGENPLUGIN/CMakeLists.txt
+++ b/doc/salome/gui/NETGENPLUGIN/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2012-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
--- a/doc/salome/gui/NETGENPLUGIN/static/footer.html
+++ b/doc/salome/gui/NETGENPLUGIN/static/footer.html
@ -4,7 +4,7 @@
  <ul>
    $navpath
    <li class="footer">
-      Copyright &copy; 2007-2024  CEA, EDF, OPEN CASCADE<br>
+      Copyright &copy; 2007-2021  CEA/DEN, EDF R&amp;D, 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>
--- a/idl/CMakeLists.txt
+++ b/idl/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2012-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
--- a/idl/NETGENPlugin_Algorithm.idl
+++ b/idl/NETGENPlugin_Algorithm.idl
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -74,13 +74,6 @@ 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
@ -154,9 +147,6 @@ module NETGENPlugin
    void    SetWorstElemMeasure(in short val );
    short   GetWorstElemMeasure();
    void    SetNbThreads(in short val );
    short   GetNbThreads();
    void    SetUseDelauney(in boolean toUse);
    boolean GetUseDelauney();
--- a/idl/NETGENPlugin_NETGEN_VERSION.idl.in
+++ b/idl/NETGENPlugin_NETGEN_VERSION.idl.in
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/resources/CMakeLists.txt
+++ b/resources/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2012-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
--- a/src/GUI/CMakeLists.txt
+++ b/src/GUI/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2012-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
--- a/src/GUI/NETGENPluginGUI.cxx
+++ b/src/GUI/NETGENPluginGUI.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/GUI/NETGENPluginGUI.h
+++ b/src/GUI/NETGENPluginGUI.h
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/GUI/NETGENPluginGUI_HypothesisCreator.cxx
+++ b/src/GUI/NETGENPluginGUI_HypothesisCreator.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/GUI/NETGENPluginGUI_HypothesisCreator.h
+++ b/src/GUI/NETGENPluginGUI_HypothesisCreator.h
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/GUI/NETGENPluginGUI_SimpleCreator.cxx
+++ b/src/GUI/NETGENPluginGUI_SimpleCreator.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/GUI/NETGENPluginGUI_SimpleCreator.h
+++ b/src/GUI/NETGENPluginGUI_SimpleCreator.h
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/CMakeLists.txt
+++ b/src/NETGENPlugin/CMakeLists.txt
@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2012-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@ -27,16 +27,15 @@ INCLUDE_DIRECTORIES(
  ${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}
@ -101,12 +100,8 @@ SET(NETGENEngine_HEADERS
  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 ---
@ -136,12 +131,8 @@ SET(NETGENEngine_SOURCES
  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
--- a/src/NETGENPlugin/NETGENPluginBuilder.py
+++ b/src/NETGENPlugin/NETGENPluginBuilder.py
@ -1,4 +1,4 @@
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@ -49,7 +49,6 @@ NETGEN_1D2D3D = "NETGEN_2D3D"
 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
@ -149,12 +148,6 @@ 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
@ -170,7 +163,7 @@ class NETGEN_Algorithm(Mesh_Algorithm):
                hypType = "NETGEN_SimpleParameters_3D"
            else:
                hypType = "NETGEN_Parameters"
-        elif self.algoType in [NETGEN_2D, NETGEN_2D_Remote]:
+        elif self.algoType == NETGEN_2D:
            hypType = "NETGEN_Parameters_2D_ONLY"
        else:
            hypType = "NETGEN_Parameters_3D"
@ -363,9 +356,6 @@ class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
    ## type of algorithm used with helper function in smeshBuilder.Mesh class
    #  @internal
    algoType = NETGEN_2D
    ## flag pointing whether this algorithm should be used by default in dynamic method
    #  of smeshBuilder.Mesh class
    isDefault  = True
    ## doc string of the method
    #  @internal
    docHelper  = "Creates triangle 2D algorithm for faces"
@ -511,33 +501,6 @@ class NETGEN_3D_Remote_Algorithm(NETGEN_3D_Algorithm):
    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
--- a/src/NETGENPlugin/NETGENPlugin_Defs.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Defs.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_DriverParam.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_DriverParam.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -26,6 +26,10 @@
 //
 #include "NETGENPlugin_DriverParam.hxx"
 #include "NETGENPlugin_Hypothesis.hxx"
 #include <SMESH_Gen.hxx>
 #include <StdMeshers_MaxElementVolume.hxx>
 #include <iostream>
 #include <fstream>
@ -38,44 +42,43 @@
 * @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 << "has_netgen_param: " << aParams.has_netgen_param << std::endl;
+  std::cout << "minh: " << aParams.minh << std::endl;
-    std::cout << "maxh: " << aParams.maxh << std::endl;
+  std::cout << "segmentsperedge: " << aParams.segmentsperedge << std::endl;
-    std::cout << "minh: " << aParams.minh << std::endl;
+  std::cout << "grading: " << aParams.grading << std::endl;
-    std::cout << "segmentsperedge: " << aParams.segmentsperedge << std::endl;
+  std::cout << "curvaturesafety: " << aParams.curvaturesafety << std::endl;
-    std::cout << "grading: " << aParams.grading << std::endl;
+  std::cout << "secondorder: " << aParams.secondorder << std::endl;
-    std::cout << "curvaturesafety: " << aParams.curvaturesafety << std::endl;
+  std::cout << "quad: " << aParams.quad << std::endl;
-    std::cout << "secondorder: " << aParams.secondorder << std::endl;
+  std::cout << "optimize: " << aParams.optimize << std::endl;
-    std::cout << "quad: " << aParams.quad << std::endl;
+  std::cout << "fineness: " << aParams.fineness << std::endl;
-    std::cout << "optimize: " << aParams.optimize << std::endl;
+  std::cout << "uselocalh: " << aParams.uselocalh << std::endl;
-    std::cout << "fineness: " << aParams.fineness << std::endl;
+  std::cout << "merge_solids: " << aParams.merge_solids << std::endl;
-    std::cout << "uselocalh: " << aParams.uselocalh << std::endl;
+  std::cout << "chordalError: " << aParams.chordalError << std::endl;
-    std::cout << "merge_solids: " << aParams.merge_solids << std::endl;
+  std::cout << "optsteps2d: " << aParams.optsteps2d << std::endl;
-    std::cout << "chordalError: " << aParams.chordalError << std::endl;
+  std::cout << "optsteps3d: " << aParams.optsteps3d << std::endl;
-    std::cout << "optsteps2d: " << aParams.optsteps2d << std::endl;
+  std::cout << "elsizeweight: " << aParams.elsizeweight << std::endl;
-    std::cout << "optsteps3d: " << aParams.optsteps3d << std::endl;
+  std::cout << "opterrpow: " << aParams.opterrpow << std::endl;
-    std::cout << "elsizeweight: " << aParams.elsizeweight << std::endl;
+  std::cout << "delaunay: " << aParams.delaunay << std::endl;
-    std::cout << "opterrpow: " << aParams.opterrpow << std::endl;
+  std::cout << "checkoverlap: " << aParams.checkoverlap << std::endl;
-    std::cout << "delaunay: " << aParams.delaunay << std::endl;
+  std::cout << "checkchartboundary: " << aParams.checkchartboundary << std::endl;
-    std::cout << "checkoverlap: " << aParams.checkoverlap << std::endl;
+  std::cout << "closeedgefac: " << aParams.closeedgefac << std::endl;
-    std::cout << "checkchartboundary: " << aParams.checkchartboundary << std::endl;
+  std::cout << "has_local_size: " << aParams.has_local_size << std::endl;
-    std::cout << "closeedgefac: " << aParams.closeedgefac << std::endl;
+  std::cout << "meshsizefilename: " << aParams.meshsizefilename << std::endl;
-    std::cout << "nbThreadMesher: " << aParams.nbThreads << std::endl;
+  std::cout << "has_maxelementvolume_hyp: " << aParams.has_maxelementvolume_hyp << std::endl;
-    std::cout << "has_local_size: " << aParams.has_local_size << std::endl;
+  std::cout << "maxElementVolume: " << aParams.maxElementVolume << std::endl;
-    std::cout << "meshsizefilename: " << aParams.meshsizefilename << std::endl;
+  std::cout << "has_LengthFromEdges_hyp: " << aParams.has_LengthFromEdges_hyp << 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)
+/**
-{
+ * @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, SMESH_Gen *gen){
  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);
@ -120,8 +123,6 @@ void importDefaultNetgenParams(const std::string param_file, netgen_params& aPar
  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;
@ -131,54 +132,37 @@ void importDefaultNetgenParams(const std::string param_file, netgen_params& aPar
  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 )
+  if(aParams.has_netgen_param){
-{
+    aParams._hypParameters = new NETGENPlugin_Hypothesis(0, gen);
  std::ifstream myfile(param_file);
  std::string line;
-  aParams.myType = !is3D ? Simple2D : Simple3D;
+    aParams._hypParameters->SetMaxSize(aParams.maxh);
-  std::getline(myfile, line);
+    aParams._hypParameters->SetMinSize(aParams.minh);
-  aParams.has_netgen_param = std::stoi(line); // 1
+    aParams._hypParameters->SetNbSegPerEdge(aParams.segmentsperedge);
-  std::getline(myfile, line);
+    aParams._hypParameters->SetGrowthRate(aParams.grading);
-  aParams.numberOfSegments = std::stoi(line); // segments      (int)
+    aParams._hypParameters->SetNbSegPerRadius(aParams.curvaturesafety);
-  std::getline(myfile, line);
+    aParams._hypParameters->SetSecondOrder(aParams.secondorder);
-  aParams.localLength = std::stod(line);      // localLenght  (double)
+    aParams._hypParameters->SetQuadAllowed(aParams.quad);
-  std::getline(myfile, line);
+    aParams._hypParameters->SetOptimize(aParams.optimize);
-  aParams.maxElementArea = std::stod(line);   // max area     (double)
+    aParams._hypParameters->SetFineness((NETGENPlugin_Hypothesis::Fineness)aParams.fineness);
-  if ( is3D )
+    aParams._hypParameters->SetSurfaceCurvature(aParams.uselocalh);
-  {
+    aParams._hypParameters->SetFuseEdges(aParams.merge_solids);
-    std::getline(myfile, line);
+    aParams._hypParameters->SetChordalErrorEnabled(aParams.chordalError);
-    aParams.maxElementVol = std::stod(line); // max volume    (double)
+    if(aParams.optimize){
-  }    
+      aParams._hypParameters->SetNbSurfOptSteps(aParams.optsteps2d);
-  std::getline(myfile, line);
+      aParams._hypParameters->SetNbVolOptSteps(aParams.optsteps3d);
-  aParams.allowQuadrangles = std::stoi(line); // int
+    }
-
+    aParams._hypParameters->SetElemSizeWeight(aParams.elsizeweight);
-  myfile.close();
+    aParams._hypParameters->SetWorstElemMeasure(aParams.opterrpow);
-};
+    aParams._hypParameters->SetUseDelauney(aParams.delaunay);
-
+    aParams._hypParameters->SetCheckOverlapping(aParams.checkoverlap);
-/**
+    aParams._hypParameters->SetCheckChartBoundary(aParams.checkchartboundary);
- * @brief Import a param_file into a netgen_params structure
+    aParams._hypParameters->SetMeshSizeFile(aParams.meshsizefilename);
 *
 * @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*/)
+  if(aParams.has_maxelementvolume_hyp){
-  {
+    aParams._hypMaxElementVolume = new StdMeshers_MaxElementVolume(1, gen);
    importDefaultNetgenParams( param_file, aParams );
  }
  else
  {
    aParams.has_netgen_param = false;
  }
  // TODO: Handle viscous layer
 };
 /**
@ -188,38 +172,31 @@ void importNetgenParams(const std::string param_file, netgen_params& aParams){
 * @param aParams the object
 */
 void exportNetgenParams(const std::string param_file, netgen_params& aParams){
-  if ( aParams.myType == Hypo ){
+  std::ofstream myfile(param_file);
-    std::ofstream myfile(param_file);
+  myfile << aParams.has_netgen_param << std::endl;
-    myfile << aParams.has_netgen_param << std::endl;
+  myfile << aParams.maxh << std::endl;
-    myfile << aParams.maxh << std::endl;
+  myfile << aParams.minh << std::endl;
-    myfile << aParams.minh << std::endl;
+  myfile << aParams.segmentsperedge << std::endl;
-    myfile << aParams.segmentsperedge << std::endl;
+  myfile << aParams.grading << std::endl;
-    myfile << aParams.grading << std::endl;
+  myfile << aParams.curvaturesafety << std::endl;
-    myfile << aParams.curvaturesafety << std::endl;
+  myfile << aParams.secondorder << std::endl;
-    myfile << aParams.secondorder << std::endl;
+  myfile << aParams.quad << std::endl;
-    myfile << aParams.quad << std::endl;
+  myfile << aParams.optimize << std::endl;
-    myfile << aParams.optimize << std::endl;
+  myfile << aParams.fineness << std::endl;
-    myfile << aParams.fineness << std::endl;
+  myfile << aParams.uselocalh << std::endl;
-    myfile << aParams.uselocalh << std::endl;
+  myfile << aParams.merge_solids << std::endl;
-    myfile << aParams.merge_solids << std::endl;
+  myfile << aParams.chordalError << std::endl;
-    myfile << aParams.chordalError << std::endl;
+  myfile << aParams.optsteps2d << std::endl;
-    myfile << aParams.optsteps2d << std::endl;
+  myfile << aParams.optsteps3d << std::endl;
-    myfile << aParams.optsteps3d << std::endl;
+  myfile << aParams.elsizeweight << std::endl;
-    myfile << aParams.elsizeweight << std::endl;
+  myfile << aParams.opterrpow << std::endl;
-    myfile << aParams.opterrpow << std::endl;
+  myfile << aParams.delaunay << std::endl;
-    myfile << aParams.delaunay << std::endl;
+  myfile << aParams.checkoverlap << std::endl;
-    myfile << aParams.checkoverlap << std::endl;
+  myfile << aParams.checkchartboundary << std::endl;
-    myfile << aParams.checkchartboundary << std::endl;
+  myfile << aParams.closeedgefac << std::endl;
-    myfile << aParams.closeedgefac << std::endl;
+  myfile << aParams.has_local_size << std::endl;
-    myfile << aParams.nbThreads << std::endl;
+  myfile << aParams.meshsizefilename << std::endl;
-    myfile << aParams.has_local_size << std::endl;
+  myfile << aParams.has_maxelementvolume_hyp << std::endl;
-    myfile << aParams.meshsizefilename << std::endl;
+  myfile << aParams.maxElementVolume << std::endl;
-    myfile << aParams.has_maxelementvolume_hyp << std::endl;
+  myfile << aParams.has_LengthFromEdges_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
  }
 };
--- a/src/NETGENPlugin/NETGENPlugin_DriverParam.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_DriverParam.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -30,17 +30,15 @@
 #include <string>
-enum hypoType{
+class NETGENPlugin_Hypothesis;
-  Hypo = 1, /*the default hypo common for 1D2D,1D2D3D && 3D*/
+class StdMeshers_MaxElementVolume;
-  Simple2D,
+class StdMeshers_ViscousLayers;
-  Simple3D
+class SMESH_Gen;
 };
 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;
@ -62,8 +60,6 @@ struct netgen_params{
  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;
@ -74,26 +70,24 @@ struct netgen_params{
  bool has_maxelementvolume_hyp=false;
  double maxElementVolume=0.0;
  NETGENPlugin_Hypothesis *    _hypParameters=nullptr;
  StdMeshers_MaxElementVolume* _hypMaxElementVolume=nullptr;
  StdMeshers_ViscousLayers*    _viscousLayersHyp=nullptr;
  double                       _progressByTic;
  bool _quadraticMesh=false;
  int _error=0;
  std::string _comment;
  // Params from NETGEN2D
  bool has_LengthFromEdges_hyp=false;
-  /////////////////////////////////////
+  // Number of threads for the mesher
-  // Quantities proper of Simple2D
+  int nbThreads;
  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 importNetgenParams(const std::string param_file, netgen_params& aParams, SMESH_Gen * gen);
 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
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -58,7 +58,6 @@ NETGENPlugin_Hypothesis::NETGENPlugin_Hypothesis (int hypId, SMESH_Gen * gen)
    _nbVolOptSteps      (GetDefaultNbVolOptSteps()),
    _elemSizeWeight     (GetDefaultElemSizeWeight()),
    _worstElemMeasure   (GetDefaultWorstElemMeasure()),
    _nbThreads          (GetDefaultNbThreads()),
    _surfaceCurvature   (GetDefaultSurfaceCurvature()),
    _useDelauney        (GetDefaultUseDelauney()),
    _checkOverlapping   (GetDefaultCheckOverlapping()),
@ -85,7 +84,7 @@ void NETGENPlugin_Hypothesis::SetMaxSize(double theSize)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetMinSize(double theSize)
@ -99,7 +98,7 @@ void NETGENPlugin_Hypothesis::SetMinSize(double theSize)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetSecondOrder(bool theVal)
@ -113,7 +112,7 @@ void NETGENPlugin_Hypothesis::SetSecondOrder(bool theVal)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetOptimize(bool theVal)
@ -127,7 +126,7 @@ void NETGENPlugin_Hypothesis::SetOptimize(bool theVal)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetFineness(Fineness theFineness)
@ -173,7 +172,7 @@ void NETGENPlugin_Hypothesis::SetFineness(Fineness theFineness)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetGrowthRate(double theRate)
@ -188,7 +187,7 @@ void NETGENPlugin_Hypothesis::SetGrowthRate(double theRate)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetNbSegPerEdge(double theVal)
@ -203,7 +202,7 @@ void NETGENPlugin_Hypothesis::SetNbSegPerEdge(double theVal)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetNbSegPerRadius(double theVal)
@ -218,7 +217,7 @@ void NETGENPlugin_Hypothesis::SetNbSegPerRadius(double theVal)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetChordalErrorEnabled(bool theVal)
@ -232,7 +231,7 @@ void NETGENPlugin_Hypothesis::SetChordalErrorEnabled(bool theVal)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetChordalError(double theVal)
@ -246,7 +245,7 @@ void NETGENPlugin_Hypothesis::SetChordalError(double theVal)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetLocalSizeOnEntry(const std::string& entry, double localSize)
@ -274,7 +273,7 @@ double NETGENPlugin_Hypothesis::GetLocalSizeOnEntry(const std::string& entry)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::UnsetLocalSizeOnEntry(const std::string& entry)
@ -285,7 +284,7 @@ void NETGENPlugin_Hypothesis::UnsetLocalSizeOnEntry(const std::string& entry)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetMeshSizeFile(const std::string& fileName)
@ -299,7 +298,7 @@ void NETGENPlugin_Hypothesis::SetMeshSizeFile(const std::string& fileName)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetQuadAllowed(bool theVal)
@ -313,7 +312,7 @@ void NETGENPlugin_Hypothesis::SetQuadAllowed(bool theVal)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 void NETGENPlugin_Hypothesis::SetSurfaceCurvature(bool theVal)
@ -341,7 +340,7 @@ void NETGENPlugin_Hypothesis::SetFuseEdges(bool theVal)
 //=======================================================================
 //function : SetNbSurfOptSteps
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis::SetNbSurfOptSteps( int theVal )
@ -355,7 +354,7 @@ void NETGENPlugin_Hypothesis::SetNbSurfOptSteps( int theVal )
 //=======================================================================
 //function : SetNbVolOptSteps
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis::SetNbVolOptSteps( int theVal )
@ -369,7 +368,7 @@ void NETGENPlugin_Hypothesis::SetNbVolOptSteps( int theVal )
 //=======================================================================
 //function : SetElemSizeWeight
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis::SetElemSizeWeight( double theVal )
@ -383,7 +382,7 @@ void NETGENPlugin_Hypothesis::SetElemSizeWeight( double theVal )
 //=======================================================================
 //function : SetWorstElemMeasure
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis::SetWorstElemMeasure( int theVal )
@ -397,7 +396,7 @@ void NETGENPlugin_Hypothesis::SetWorstElemMeasure( int theVal )
 //=======================================================================
 //function : SetUseDelauney
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis::SetUseDelauney( bool theVal )
@ -411,7 +410,7 @@ void NETGENPlugin_Hypothesis::SetUseDelauney( bool theVal )
 //=======================================================================
 //function : SetCheckOverlapping
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis::SetCheckOverlapping( bool theVal )
@ -425,7 +424,7 @@ void NETGENPlugin_Hypothesis::SetCheckOverlapping( bool theVal )
 //=======================================================================
 //function : SetCheckChartBoundary
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis::SetCheckChartBoundary( bool theVal )
@ -437,20 +436,6 @@ void NETGENPlugin_Hypothesis::SetCheckChartBoundary( bool theVal )
  }
 }
 //=======================================================================
 //function : SetNbThreads
 //purpose  :
 //=======================================================================
 void NETGENPlugin_Hypothesis::SetNbThreads( int theVal )
 {
  if (theVal != _nbThreads)
  {
    _nbThreads = theVal;
    NotifySubMeshesHypothesisModification();
  }
 }
 //=============================================================================
 /*!
 *
@ -500,7 +485,7 @@ ostream & NETGENPlugin_Hypothesis::SaveTo(ostream & save)
 //=============================================================================
 /*!
- *
+ *  
 */
 //=============================================================================
 istream & NETGENPlugin_Hypothesis::LoadFrom(istream & load)
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -35,7 +35,6 @@
 #include "Utils_SALOME_Exception.hxx"
 #include <map>
 #include <thread>
 //  Parameters for work of NETGEN
 //
@ -126,9 +125,6 @@ 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; }
@ -149,7 +145,6 @@ 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);
@ -202,9 +197,6 @@ private:
  //bool          _blockFilling; -- not used by netgen
  // (SALOME additions)
  bool          _fuseEdges;
  // Parallelism parameters
  int _nbThreads;
 };
 #endif
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_ONLY_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_ONLY_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_ONLY_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_ONLY_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_2D_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_3D_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_3D_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_3D_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_3D_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -60,7 +60,7 @@ bool NETGENPlugin_Hypothesis_i::isToSetParameter<double>(double curValue,
 NETGENPlugin_Hypothesis_i::
 NETGENPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
                           ::SMESH_Gen*            theGenImpl)
-  : SALOME::GenericObj_i( thePOA ),
+  : SALOME::GenericObj_i( thePOA ), 
    SMESH_Hypothesis_i( thePOA ),
    mySetMethodFlags(0)
 {
@ -471,7 +471,7 @@ CORBA::Boolean NETGENPlugin_Hypothesis_i::GetFuseEdges()
 //=======================================================================
 //function : SetNbSurfOptSteps
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis_i::SetNbSurfOptSteps(CORBA::Short nb )
@ -495,7 +495,7 @@ CORBA::Short NETGENPlugin_Hypothesis_i::GetNbSurfOptSteps()
 //=======================================================================
 //function : SetNbVolOptSteps
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis_i::SetNbVolOptSteps(CORBA::Short nb )
@ -520,7 +520,7 @@ CORBA::Short NETGENPlugin_Hypothesis_i::GetNbVolOptSteps()
 //=======================================================================
 //function : SetElemSizeWeight
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis_i::SetElemSizeWeight(CORBA::Double size )
@ -544,7 +544,7 @@ CORBA::Double NETGENPlugin_Hypothesis_i::GetElemSizeWeight()
 //=======================================================================
 //function : SetWorstElemMeasure
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis_i::SetWorstElemMeasure(CORBA::Short val )
@ -558,7 +558,7 @@ void NETGENPlugin_Hypothesis_i::SetWorstElemMeasure(CORBA::Short val )
 //=======================================================================
 //function : GetWorstElemMeasure
-//purpose  :
+//purpose  : 
 //=======================================================================
 CORBA::Short NETGENPlugin_Hypothesis_i::GetWorstElemMeasure()
@ -566,33 +566,9 @@ 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  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis_i::SetUseDelauney(CORBA::Boolean toUse)
@ -606,7 +582,7 @@ void NETGENPlugin_Hypothesis_i::SetUseDelauney(CORBA::Boolean toUse)
 //=======================================================================
 //function : GetUseDelauney
-//purpose  :
+//purpose  : 
 //=======================================================================
 CORBA::Boolean NETGENPlugin_Hypothesis_i::GetUseDelauney()
@ -616,7 +592,7 @@ CORBA::Boolean NETGENPlugin_Hypothesis_i::GetUseDelauney()
 //=======================================================================
 //function : SetCheckOverlapping
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis_i::SetCheckOverlapping(CORBA::Boolean toCheck )
@ -630,7 +606,7 @@ void NETGENPlugin_Hypothesis_i::SetCheckOverlapping(CORBA::Boolean toCheck )
 //=======================================================================
 //function : GetCheckOverlapping
-//purpose  :
+//purpose  : 
 //=======================================================================
 CORBA::Boolean NETGENPlugin_Hypothesis_i::GetCheckOverlapping()
@ -640,7 +616,7 @@ CORBA::Boolean NETGENPlugin_Hypothesis_i::GetCheckOverlapping()
 //=======================================================================
 //function : SetCheckChartBoundary
-//purpose  :
+//purpose  : 
 //=======================================================================
 void NETGENPlugin_Hypothesis_i::SetCheckChartBoundary(CORBA::Boolean toCheck )
@ -676,13 +652,13 @@ CORBA::Boolean NETGENPlugin_Hypothesis_i::GetCheckChartBoundary()
 //================================================================================
 /*!
- * \brief Verify whether hypothesis supports given entity type
+ * \brief Verify whether hypothesis supports given entity type 
  * \param type - dimension (see SMESH::Dimension enumeration)
  * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
- *
+ * 
 * Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
 */
-//================================================================================
+//================================================================================  
 CORBA::Boolean NETGENPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
 {
  return type == SMESH::DIM_3D;
--- a/src/NETGENPlugin/NETGENPlugin_Hypothesis_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Hypothesis_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -113,9 +113,6 @@ 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();
@ -128,7 +125,7 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Hypothesis_i:
  // Get implementation
  ::NETGENPlugin_Hypothesis* GetImpl();
-  // Verify whether hypothesis supports given entity type
+  // Verify whether hypothesis supports given entity type 
  CORBA::Boolean IsDimSupported( SMESH::Dimension type );
--- a/src/NETGENPlugin/NETGENPlugin_Mesher.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Mesher.cxx
--- a/src/NETGENPlugin/NETGENPlugin_Mesher.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Mesher.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -35,17 +35,8 @@
 #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
+#include <TopTools_IndexedMapOfShape.hxx>
 #ifndef OCCGEOMETRY
 #define OCCGEOMETRY
 #endif
 #include <occgeom.hpp>
 #include <meshing.hpp>
 namespace nglib {
 #include <nglib.h>
@ -67,35 +58,7 @@ 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
@ -142,15 +105,11 @@ struct NETGENPLUGIN_EXPORT NETGENPlugin_NetgenLibWrapper
  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;
@ -181,56 +140,7 @@ 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);
@ -302,19 +212,6 @@ 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;
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_1D2D3D_SA.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_1D2D3D_SA.cxx
@ -1,386 +0,0 @@
 // 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;
 }
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_1D2D3D_SA.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_1D2D3D_SA.hxx
@ -1,63 +0,0 @@
 // 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
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, 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,6 +22,8 @@
 // Project   : SALOME
 //
 #include "NETGENPlugin_NETGEN_2D_ONLY.hxx"
 #include "NETGENPlugin_Mesher.hxx"
 #include "NETGENPlugin_Hypothesis_2D.hxx"
 #include <SMDS_MeshElement.hxx>
@ -44,8 +46,6 @@
 #include <utilities.h>
 #include <GEOMUtils.hxx>
 #include <list>
 #include <vector>
 #include <limits>
@ -61,23 +61,6 @@ 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
@ -91,264 +74,6 @@ 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 );
  }
 }
 //=============================================================================
 /*!
 *
@ -492,470 +217,6 @@ 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
@ -977,7 +238,6 @@ 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:
@ -994,11 +254,81 @@ bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh&         aMesh,
  //    max = max segment len of a FACE
  NETGENPlugin_Mesher aMesher( &aMesh, aShape, /*isVolume=*/false);
-  auto options = SetParameteres( aMesh, aShape, aMesher, ngMeshes[0], occgeoComm );
+  aMesher.SetParameters( _hypParameters ); // _hypParameters -> netgen::mparam
  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
    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
  // ==================
@ -1052,10 +382,51 @@ bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh&         aMesh,
    // compute maxh of a FACE
    // ----------------------
-    bool setMaxh = ComputeMaxhOfFace( F, aMesher, wires, occgeoComm, isDefaultHyp, isCommonLocalSize );
+    if ( !_hypParameters )
-    if (!setMaxh)
+    {
-      return setMaxh;
+      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( F, netgen::mparam.maxh );
      }
    }
    // prepare occgeom
    netgen::OCCGeometry occgeom;
    occgeom.shape = F;
@ -1175,10 +546,52 @@ 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
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, 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,10 +26,6 @@
 #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;
@ -54,7 +50,7 @@ public:
                               Hypothesis_Status&  aStatus);
  virtual bool Compute(SMESH_Mesh&         aMesh,
-                       const TopoDS_Shape& aShape);  
+                       const TopoDS_Shape& aShape);
  virtual void CancelCompute();
@ -63,29 +59,6 @@ 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;
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote.cxx
@ -1,350 +0,0 @@
 // 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);
 }
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote.hxx
@ -1,73 +0,0 @@
 // 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
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote_i.cxx
@ -1,77 +0,0 @@
 // 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;
 }
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_Remote_i.hxx
@ -1,58 +0,0 @@
 // 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
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_SA.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_SA.cxx
@ -1,298 +0,0 @@
 // 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;
 }
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_SA.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_SA.hxx
@ -1,64 +0,0 @@
 // 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
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -32,6 +32,9 @@
 #include "NETGENPlugin_Hypothesis.hxx"
 // TODO: remove use of netgen_param
 #include "NETGENPlugin_DriverParam.hxx"
 #include <SMDS_MeshElement.hxx>
 #include <SMDS_MeshNode.hxx>
 #include <SMESHDS_Mesh.hxx>
@ -198,27 +201,19 @@ bool NETGENPlugin_NETGEN_3D::CheckHypothesis (SMESH_Mesh&         aMesh,
 */
 //=============================================================================
 /**
- * @brief Compute the list of already meshed Surface elements and info
+ * @brief Get an iterator on the Surface element with their orientation
 *        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
+    netgen_params &aParams,
    std::map<const SMDS_MeshElement*, tuple<bool, bool>>& listElements
 )
 {
  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
@ -241,7 +236,7 @@ bool NETGENPlugin_NETGEN_3D::getSurfaceElements(
    if ( !aSubMeshDSFace ) continue;
    SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
-    if ( _quadraticMesh &&
+    if ( aParams._quadraticMesh &&
          dynamic_cast< const SMESH_ProxyMesh::SubMesh*>( aSubMeshDSFace ))
    {
      // add medium nodes of proxy triangles to helper (#16843)
@ -254,30 +249,22 @@ bool NETGENPlugin_NETGEN_3D::getSurfaceElements(
      const SMDS_MeshElement* elem = iteratorElem->next();
      // check mesh face
      if ( !elem ){
-        return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
+        aParams._error = COMPERR_BAD_INPUT_MESH;
        aParams._comment = "Null element encounters";
        return true;
      }
      if ( elem->NbCornerNodes() != 3 ){
-        return error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
+        aParams._error = COMPERR_BAD_INPUT_MESH;
        aParams._comment = "Not triangle element encounters";
        return true;
      }
-      listElements[elem] = tuple<bool, bool>(isRev, isInternalFace);
+      listElements[elem] = tuple(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,
@ -285,15 +272,16 @@ bool NETGENPlugin_NETGEN_3D::computeFillNgMesh(
  vector< const SMDS_MeshNode* > &nodeVec,
  NETGENPlugin_NetgenLibWrapper &ngLib,
  SMESH_MesherHelper &helper,
  netgen_params &aParams,
  int &Netgen_NbOfNodes)
 {
  netgen::multithread.terminate = 0;
  netgen::multithread.task = "Volume meshing";
-  _progressByTic = -1.;
+  aParams._progressByTic = -1.;
  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
-  _quadraticMesh = helper.IsQuadraticSubMesh(aShape);
+  aParams._quadraticMesh = helper.IsQuadraticSubMesh(aShape);
  helper.SetElementsOnShape( true );
  Netgen_NbOfNodes = 0;
@ -309,8 +297,6 @@ bool NETGENPlugin_NETGEN_3D::computeFillNgMesh(
    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;
@ -325,10 +311,10 @@ bool NETGENPlugin_NETGEN_3D::computeFillNgMesh(
    bool isInternalFace=false;
    SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( aMesh ));
-    if ( _viscousLayersHyp )
+    if ( aParams._viscousLayersHyp )
    {
      netgen::multithread.percent = 3;
-      proxyMesh = _viscousLayersHyp->Compute( aMesh, aShape );
+      proxyMesh = aParams._viscousLayersHyp->Compute( aMesh, aShape );
      if ( !proxyMesh )
        return false;
    }
@ -340,10 +326,8 @@ bool NETGENPlugin_NETGEN_3D::computeFillNgMesh(
      proxyMesh.reset( Adaptor );
    }
-    // map must be sorted by ID to ensure that we will have the same number of
+    std::map<const SMDS_MeshElement*, tuple<bool, bool>> listElements;
-    // 3D element if we recompute
+    bool ret = getSurfaceElements(aMesh, aShape, proxyMesh, internals, helper, aParams, listElements);
    std::map<const SMDS_MeshElement*, tuple<bool, bool>, TIDCompare> listElements;
    bool ret = getSurfaceElements(aMesh, aShape, proxyMesh, internals, helper, listElements);
    if(ret)
      return ret;
@ -413,21 +397,12 @@ bool NETGENPlugin_NETGEN_3D::computeFillNgMesh(
  return false;
 }
 /**
 * @brief Part of Compute: Setting the netgen parameters from the Hypothesis
 *
 * @param aMesh Global mesh
 * @param ngLib Wrapper on netgen lib
 * @param occgeo Mapping between nodes mesh id and netgen structure id
 * @param helper helper assocaited to the mesh
 * @param endWith end step of netgen
 * @return true if there was some error
 */
 bool NETGENPlugin_NETGEN_3D::computePrepareParam(
  SMESH_Mesh&         aMesh,
  NETGENPlugin_NetgenLibWrapper &ngLib,
  netgen::OCCGeometry &occgeo,
  SMESH_MesherHelper &helper,
  netgen_params &aParams,
  int &endWith)
 {
@ -437,33 +412,36 @@ bool NETGENPlugin_NETGEN_3D::computePrepareParam(
  NETGENPlugin_Mesher aMesher( &aMesh, helper.GetSubShape(), /*isVolume=*/true );
  if ( _hypParameters )
  {
    aMesher.SetParameters( _hypParameters );
-    if ( !_hypParameters->GetLocalSizesAndEntries().empty() ||
+  if ( aParams._hypParameters )
-         !_hypParameters->GetMeshSizeFile().empty() )
+  {
    aMesher.SetParameters( aParams._hypParameters );
    if ( !aParams._hypParameters->GetLocalSizesAndEntries().empty() ||
         !aParams._hypParameters->GetMeshSizeFile().empty() )
    {
      if ( ! &ngMesh->LocalHFunction() )
      {
        netgen::Point3d pmin, pmax;
        ngMesh->GetBox( pmin, pmax, 0 );
-        ngMesh->SetLocalH( pmin, pmax, _hypParameters->GetGrowthRate() );
+        ngMesh->SetLocalH( pmin, pmax, aParams._hypParameters->GetGrowthRate() );
      }
      aMesher.SetLocalSize( occgeo, *ngMesh );
      try {
        ngMesh->LoadLocalMeshSize( netgen::mparam.meshsizefilename );
      } catch (netgen::NgException & ex) {
-        return error( COMPERR_BAD_PARMETERS, ex.What() );
+        aParams._error = COMPERR_BAD_PARMETERS;
        aParams._comment = ex.What();
        return false;
      }
    }
-    if ( !_hypParameters->GetOptimize() )
+    if ( !aParams._hypParameters->GetOptimize() )
      endWith = netgen::MESHCONST_MESHVOLUME;
  }
-  else if ( _hypMaxElementVolume )
+  else if ( aParams._hypMaxElementVolume )
  {
-    netgen::mparam.maxh = pow( 72, 1/6. ) * pow( _maxElementVolume, 1/3. );
+    netgen::mparam.maxh = pow( 72, 1/6. ) * pow( aParams.maxElementVolume, 1/3. );
    // limitVolumeSize( ngMesh, mparam.maxh ); // result is unpredictable
  }
  else if ( aMesh.HasShapeToMesh() )
@ -478,29 +456,19 @@ bool NETGENPlugin_NETGEN_3D::computePrepareParam(
    netgen::mparam.maxh = Dist(pmin, pmax)/2;
  }
-  if ( !_hypParameters && aMesh.HasShapeToMesh() )
+  if ( !aParams._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,
  netgen_params &aParams,
  int &startWith, int &endWith)
 {
  int err = 1;
@ -515,7 +483,8 @@ bool NETGENPlugin_NETGEN_3D::computeRunMesher(
    if(netgen::multithread.terminate)
      return false;
    if ( err ){
-      error(SMESH_Comment("Error in netgen::OCCGenerateMesh() at ") << netgen::multithread.task);
+      aParams._comment = SMESH_Comment("Error in netgen::OCCGenerateMesh() at ") << netgen::multithread.task;
      return true;
    }
  }
  catch (Standard_Failure& ex)
@ -525,7 +494,8 @@ bool NETGENPlugin_NETGEN_3D::computeRunMesher(
        << ": " << ex.DynamicType()->Name();
    if ( ex.GetMessageString() && strlen( ex.GetMessageString() ))
      str << ": " << ex.GetMessageString();
-    error(str);
+    aParams._comment = str;
    return true;
  }
  catch (netgen::NgException& exc)
  {
@ -533,36 +503,31 @@ bool NETGENPlugin_NETGEN_3D::computeRunMesher(
    if ( strlen( netgen::multithread.task ) > 0 )
      str << " at " << netgen::multithread.task;
    str << ": " << exc.What();
-    error(str);
+    aParams._comment = str;
    return true;
  }
  catch (...)
  {
    SMESH_Comment str("Exception in  netgen::OCCGenerateMesh()");
    if ( strlen( netgen::multithread.task ) > 0 )
      str << " at " << netgen::multithread.task;
-    error(str);
+    aParams._comment = str;
    return true;
  }
  if ( err )
  {
    SMESH_ComputeErrorPtr ce = NETGENPlugin_Mesher::ReadErrors(nodeVec);
    if ( ce && ce->HasBadElems() ){
-      error( ce );
+      aParams._error = ce->myName;
      aParams._comment = ce->myComment;
      return true;
    }
  }
  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,
@ -609,14 +574,6 @@ bool NETGENPlugin_NETGEN_3D::computeFillMesh(
  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)
@ -629,13 +586,32 @@ bool NETGENPlugin_NETGEN_3D::Compute(
  int endWith   = netgen::MESHCONST_OPTVOLUME;
  int Netgen_NbOfNodes;
-  computeFillNgMesh(aMesh, aShape, nodeVec, ngLib, helper, Netgen_NbOfNodes);
+  netgen_params aParams;
  aParams._hypParameters = const_cast<NETGENPlugin_Hypothesis*>(_hypParameters);
  aParams._hypMaxElementVolume = const_cast<StdMeshers_MaxElementVolume*>(_hypMaxElementVolume);
  aParams.maxElementVolume = _maxElementVolume;
  aParams._progressByTic = _progressByTic;
  aParams._quadraticMesh = _quadraticMesh;
  aParams._viscousLayersHyp = const_cast<StdMeshers_ViscousLayers*>(_viscousLayersHyp);
  bool ret;
  ret = computeFillNgMesh(aMesh, aShape, nodeVec, ngLib, helper, aParams, Netgen_NbOfNodes);
  if(ret)
    return error( aParams._error, aParams._comment);
  netgen::OCCGeometry occgeo;
-  computePrepareParam(aMesh, ngLib, occgeo, helper, endWith);
+  computePrepareParam(aMesh, ngLib, occgeo, helper, aParams, endWith);
-  computeRunMesher(occgeo, nodeVec, ngLib._ngMesh, ngLib, startWith, endWith);
+  ret = computeRunMesher(occgeo, nodeVec, ngLib._ngMesh, ngLib, aParams, startWith, endWith);
  if(ret){
    if(aParams._error)
      return error(aParams._error, aParams._comment);
    error(aParams._comment);
    return true;
  }
  computeFillMesh(nodeVec, ngLib, helper, Netgen_NbOfNodes);
  return false;
 }
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -77,6 +77,7 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D: public SMESH_3D_Algo
    std::vector< const SMDS_MeshNode* > &nodeVec,
    NETGENPlugin_NetgenLibWrapper &ngLib,
    SMESH_MesherHelper &helper,
    netgen_params &aParams,
    int &Netgen_NbOfNodes);
  bool computePrepareParam(
@ -84,6 +85,7 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D: public SMESH_3D_Algo
    NETGENPlugin_NetgenLibWrapper &ngLib,
    netgen::OCCGeometry &occgeo,
    SMESH_MesherHelper &helper,
    netgen_params &aParams,
    int &endWith);
  bool computeRunMesher(
@ -91,6 +93,7 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D: public SMESH_3D_Algo
    std::vector< const SMDS_MeshNode* > &nodeVec,
    netgen::Mesh* ngMesh,
    NETGENPlugin_NetgenLibWrapper &ngLib,
    netgen_params &aParams,
    int &startWith, int &endWith);
  bool computeFillMesh(
@ -107,7 +110,8 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D: public SMESH_3D_Algo
    SMESH_ProxyMesh::Ptr proxyMesh,
    NETGENPlugin_Internals &internals,
    SMESH_MesherHelper &helper,
-    std::map<const SMDS_MeshElement*, std::tuple<bool, bool>, TIDCompare>& listElements);
+    netgen_params &aParams,
    std::map<const SMDS_MeshElement*, std::tuple<bool, bool>>& listElements);
  bool compute(SMESH_Mesh&                          mesh,
               SMESH_MesherHelper&                  helper,
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -35,22 +35,19 @@
 #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
 */
@ -82,7 +79,7 @@ using namespace nglib;
 //=============================================================================
 /*!
- * Constructor
+ *
 */
 //=============================================================================
@ -94,7 +91,7 @@ NETGENPlugin_NETGEN_3D_Remote::NETGENPlugin_NETGEN_3D_Remote(int hypId, SMESH_Ge
 //=============================================================================
 /*!
- * Destructor
+ *
 */
 //=============================================================================
@ -102,15 +99,9 @@ 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();
@ -133,27 +124,21 @@ void NETGENPlugin_NETGEN_3D_Remote::fillParameters(const NETGENPlugin_Hypothesis
 #ifdef NETGEN_V6
  // std::string
  aParams.meshsizefilename = hyp->GetMeshSizeFile();
  aParams.closeedgefac = 2;
  aParams.nbThreads = hyp->GetNbThreads();
 #else
  // const char*
  aParams.meshsizefilename = hyp->GetMeshSizeFile();
 #endif
 #ifdef NETGEN_V6
  aParams.closeedgefac = 2;
 #else
  aParams.closeedgefac = 0;
  aParams.nbThreads = 0;
 #endif
 }
-//
+// write in a binary file the orientation for each 2D element of the mesh
 /**
 * @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,
                                                      netgen_params& aParams,
                                                      const std::string output_file)
 {
  SMESH_MesherHelper helper(aMesh);
@ -177,7 +162,7 @@ void NETGENPlugin_NETGEN_3D_Remote::exportElementOrientation(SMESH_Mesh& aMesh,
    if ( !aSubMeshDSFace ) continue;
    SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
-    if ( _quadraticMesh &&
+    if ( aParams._quadraticMesh &&
          dynamic_cast< const SMESH_ProxyMesh::SubMesh*>( aSubMeshDSFace ))
    {
      // add medium nodes of proxy triangles to helper (#16843)
@ -210,32 +195,20 @@ void NETGENPlugin_NETGEN_3D_Remote::exportElementOrientation(SMESH_Mesh& aMesh,
  }
 }
-/**
+
 * @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)
 {
-  {
+  aMesh.Lock();
-    SMESH_MeshLocker myLocker(&aMesh);
+  SMESH_Hypothesis::Hypothesis_Status hypStatus;
-    SMESH_Hypothesis::Hypothesis_Status hypStatus;
+  NETGENPlugin_NETGEN_3D::CheckHypothesis(aMesh, aShape, 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 = aMesh.tmp_folder / fs::unique_path(fs::path("Volume-%%%%-%%%%"));
  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 mesh_file=aMesh.tmp_folder / 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");
@ -244,99 +217,79 @@ bool NETGENPlugin_NETGEN_3D_Remote::Compute(SMESH_Mesh&         aMesh,
  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");
+  fs::path cmd_file=tmp_folder / fs::path("cmd.log");
-  // TODO: See if we can retreived name from aMesh ?
+  //TODO: Handle variable mesh_name
  std::string mesh_name = "MESH";
-  {
+  //Writing Shape
-    SMESH_MeshLocker myLocker(&aMesh);
+  exportShape(shape_file.string(), aShape);
    //Writing Shape
    SMESH_DriverShape::exportShape(shape_file.string(), aShape);
-    //Writing hypo
+  //Writing hypo
-    netgen_params aParams;
+  netgen_params aParams;
-    fillParameters(_hypParameters, aParams);
+  fillParameters(_hypParameters, aParams);
-    exportNetgenParams(param_file.string(), aParams);
+  exportNetgenParams(param_file.string(), aParams);
-    // Exporting element orientation
+  // Exporting element orientation
-    exportElementOrientation(aMesh, aShape, element_orientation_file.string());
+  exportElementOrientation(aMesh, aShape, aParams, element_orientation_file.string());
  }
  aMesh.Unlock();
  // Calling run_mesher
-  // Path to mesher script
+  // TODO: check if we need to handle the .exe for windows
-  fs::path mesher_launcher = fs::path(std::getenv("SMESH_ROOT_DIR"))/
+  std::string cmd;
-       fs::path("bin")/
+  fs::path run_mesher_exe =
-       fs::path("salome")/
+    fs::path(std::getenv("NETGENPLUGIN_ROOT_DIR"))/
-       fs::path("mesher_launcher.py");
+    fs::path("bin")/
    fs::path("salome")/
    fs::path("NETGENPlugin_Runner");
-
+  cmd = run_mesher_exe.string() +
-  std::string s_program="python3";
+                  " NETGEN3D " + mesh_file.string() + " "
-  std::list<std::string> params;
+                               + shape_file.string() + " "
-  params.push_back(mesher_launcher.string());
+                               + param_file.string() + " "
-  params.push_back("NETGEN3D");
+                               + element_orientation_file.string() + " "
-  params.push_back(mesh_file.string());
+                               + std::to_string(aMesh.GetMesherNbThreads()) + " "
-  params.push_back(shape_file.string());
+                               + new_element_file.string() + " "
-  params.push_back(param_file.string());
+                               + "NONE";
-  params.push_back("--elem-orient-file=" + element_orientation_file.string());
+  // Writing command in log
  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;
    flog << endl;
  }
  MESSAGE("Running command: ");
  MESSAGE(cmd);
  // Building arguments for QProcess
-  QString program = QString::fromStdString(s_program);
+  QString program = run_mesher_exe.c_str();
  QStringList arguments;
-  for(auto arg : params){
+  arguments << "NETGEN3D";
-    arguments << arg.c_str();
+  arguments << mesh_file.c_str();
-  }
+  arguments << shape_file.c_str();
-
+  arguments << param_file.c_str();
-  QString out_file = log_file.string().c_str();
+  arguments << element_orientation_file.c_str();
  arguments << std::to_string(aMesh.GetMesherNbThreads()).c_str();
  arguments << new_element_file.c_str();
  arguments << "NONE";
  QString out_file = log_file.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
+  myProcess.waitForFinished();
-  // the process otherwise it just waits 30 seconds)
+  int ret = myProcess.exitStatus();
  bool finished = myProcess.waitForFinished(-1);
  int ret = myProcess.exitCode();
-  if(ret != 0 || !finished){
+  if(ret != 0){
    // Run crahed
-    std::string msg = "Issue with mesh_launcher: \n";
+    std::cerr << "Issue with command: " << std::endl;
-    msg += "See log for more details: " + log_file.string() + "\n";
+    std::cerr << "See log for more details: " << log_file.string() << std::endl;
-    msg += cmd + "\n";
+    std::cerr << cmd << std::endl;
-    throw SALOME_Exception(msg);
+    return false;
  }
  aMesh.Lock();
  {
    SMESH_MeshLocker myLocker(&aMesh);
    std::ifstream df(new_element_file.string(), ios::binary);
    int Netgen_NbOfNodes;
@ -391,16 +344,7 @@ bool NETGENPlugin_NETGEN_3D_Remote::Compute(SMESH_Mesh&         aMesh,
    }
  }
-  return true;
+  aMesh.Unlock();
 }
-/**
+  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);
 }
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -53,17 +53,16 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D_Remote: public NETGENPlugin_NET
  // 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;};
+                        Hypothesis_Status&  aStatus){aStatus = HYP_OK;return true;};
  bool Compute(SMESH_Mesh&         aMesh,
-              const TopoDS_Shape& aShape) override;
+              const TopoDS_Shape& aShape);
  void setSubMeshesToCompute(SMESH_subMesh * aSubMesh) override;
 protected:
  void exportElementOrientation(SMESH_Mesh& aMesh,
                                const TopoDS_Shape& aShape,
                                netgen_params& aParams,
                                const std::string output_file);
  void fillParameters(const NETGENPlugin_Hypothesis* hyp,
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_Remote_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_SA.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_SA.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -32,7 +32,6 @@
 #include "NETGENPlugin_DriverParam.hxx"
 #include "NETGENPlugin_Hypothesis.hxx"
 #include "StdMeshers_MaxElementVolume.hxx"
 #include <SMESH_Gen.hxx>
 #include <SMESH_Mesh.hxx>
@ -42,13 +41,8 @@
 #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
@ -81,19 +75,19 @@ using namespace nglib;
 //=============================================================================
 /*!
- * Constructor
+ *
 */
 //=============================================================================
 NETGENPlugin_NETGEN_3D_SA::NETGENPlugin_NETGEN_3D_SA()
-  :  NETGENPlugin_NETGEN_3D(0, new SMESH_Gen())
+  : NETGENPlugin_NETGEN_3D(0, _gen=new SMESH_Gen())
 {
  _name = "NETGEN_3D_SA";
 }
 //=============================================================================
 /*!
- * Destructor
+ *
 */
 //=============================================================================
@ -103,59 +97,7 @@ NETGENPlugin_NETGEN_3D_SA::~NETGENPlugin_NETGEN_3D_SA()
    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,
@ -163,11 +105,11 @@ bool NETGENPlugin_NETGEN_3D_SA::computeFillNewElementFile(
    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() )
  {
@ -206,24 +148,11 @@ bool NETGENPlugin_NETGEN_3D_SA::computeFillNewElementFile(
  return false;
 }
-/**
+
- * @brief Compute mesh associated to shape
+bool NETGENPlugin_NETGEN_3D_SA::Compute(TopoDS_Shape &aShape, SMESH_Mesh& aMesh, netgen_params& aParams,
- *
+                     std::string new_element_file, std::string element_orientation_file,
- * @param aShape the shape
+                     bool output_mesh)
 * @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;
@ -232,18 +161,22 @@ bool NETGENPlugin_NETGEN_3D_SA::Compute(
  int endWith   = netgen::MESHCONST_OPTVOLUME;
  int Netgen_NbOfNodes=0;
-  // Changing netgen log_file putting it next to new_element_file
+  bool ret;
-  fs::path netgen_log_file = fs::path(new_element_file).remove_filename() / fs::path("NETGEN.out");
+  ret = NETGENPlugin_NETGEN_3D::computeFillNgMesh(aMesh, aShape, nodeVec, ngLib, helper, aParams, Netgen_NbOfNodes);
-  MESSAGE("netgen ouput"<<netgen_log_file.string());
+  if(ret)
-
+    return error( aParams._error, aParams._comment);
  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::computePrepareParam(aMesh, ngLib, occgeo, helper, aParams, endWith);
-  NETGENPlugin_NETGEN_3D::computeRunMesher(occgeo, nodeVec, ngLib._ngMesh, ngLib, startWith, endWith);
+  ret = NETGENPlugin_NETGEN_3D::computeRunMesher(occgeo, nodeVec, ngLib._ngMesh, ngLib, aParams, startWith, endWith);
  if(ret){
    if(aParams._error)
      return error(aParams._error, aParams._comment);
    error(aParams._comment);
    return true;
  }
  computeFillNewElementFile(nodeVec, ngLib, new_element_file, Netgen_NbOfNodes);
@ -253,44 +186,37 @@ bool NETGENPlugin_NETGEN_3D_SA::Compute(
  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)
+          const std::string output_mesh_file,
          int nbThreads)
 {
  _element_orientation_file = element_orientation_file;
  // Importing mesh
  SMESH_Gen gen;
-  std::unique_ptr<SMESH_Mesh> myMesh(_gen->CreateMesh(false));
+  std::unique_ptr<SMESH_Mesh> myMesh(gen.CreateMesh(false));
-  SMESH_DriverMesh::importMesh(input_mesh_file, *myMesh);
+  importMesh(input_mesh_file, *myMesh);
  // Importing shape
  TopoDS_Shape myShape;
-  SMESH_DriverShape::importShape(shape_file, myShape);
+  importShape(shape_file, myShape);
  // Importing hypothesis
  netgen_params myParams;
-  importNetgenParams(hypo_file, myParams);
+  importNetgenParams(hypo_file, myParams, &gen);
-  fillHyp(myParams);
+  // Setting number of threads for netgen
  myParams.nbThreads = nbThreads;
  MESSAGE("Meshing with netgen3d");
  int ret = Compute(myShape, *myMesh, myParams,
-                      new_element_file,
+                      new_element_file, element_orientation_file,
                      !output_mesh_file.empty());
@ -301,39 +227,23 @@ int NETGENPlugin_NETGEN_3D_SA::run(const std::string input_mesh_file,
  if(!output_mesh_file.empty()){
    std::string meshName = "MESH";
-    SMESH_DriverMesh::exportMesh(output_mesh_file, *myMesh, meshName);
+    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
+    netgen_params &aParams,
    std::map<const SMDS_MeshElement*, tuple<bool, bool>>& 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
@ -373,6 +283,7 @@ bool NETGENPlugin_NETGEN_3D_SA::getSurfaceElements(
  // Adding elements from Mesh
  SMDS_ElemIteratorPtr iteratorElem = meshDS->elementsIterator(SMDSAbs_Face);
  bool isRev;
  bool isInternalFace = false;
  bool isIn;
@ -381,10 +292,14 @@ bool NETGENPlugin_NETGEN_3D_SA::getSurfaceElements(
    // check mesh face
    const SMDS_MeshElement* elem = iteratorElem->next();
    if ( !elem ){
-      return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
+      aParams._error = COMPERR_BAD_INPUT_MESH;
      aParams._comment = "Null element encounters";
      return true;
    }
    if ( elem->NbCornerNodes() != 3 ){
-      return error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
+      aParams._error = COMPERR_BAD_INPUT_MESH;
      aParams._comment = "Not triangle element encounters";
      return true;
    }
    // Keeping only element that are in the element orientation file
    isIn = elemOrientation.count(elem->GetID())==1;
@ -393,7 +308,7 @@ bool NETGENPlugin_NETGEN_3D_SA::getSurfaceElements(
    // Get orientation
    // Netgen requires that all the triangle point outside
    isRev = elemOrientation[elem->GetID()];
-    listElements[elem] = tuple<bool, bool>(isRev, false);
+    listElements[elem] = tuple(isRev, false);
  }
  return false;
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_SA.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_SA.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -38,6 +38,7 @@
 class NETGENPlugin_NetgenLibWrapper;
 class netgen_params;
 class SMDS_MeshNode;
 class SMESH_Gen;
 using namespace std;
@ -47,16 +48,19 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D_SA: public NETGENPlugin_NETGEN_
  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);
+                       std::string new_element_file, std::string element_orientation_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);
+          const std::string output_mesh_file,
          int nbThreads);
 protected:
@ -72,10 +76,13 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D_SA: public NETGENPlugin_NETGEN_
    SMESH_ProxyMesh::Ptr proxyMesh,
    NETGENPlugin_Internals &internals,
    SMESH_MesherHelper &helper,
-    std::map<const SMDS_MeshElement*, tuple<bool, bool>, TIDCompare>& listElements
+    netgen_params &aParams,
-    ) override;
+    std::map<const SMDS_MeshElement*, tuple<bool, bool>>& listElements
    );
   std::string _element_orientation_file="";
   SMESH_Gen *_gen=nullptr;
 };
 #endif
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Remesher_2D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Remesher_2D.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Remesher_2D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Remesher_2D.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--- a/src/NETGENPlugin/NETGENPlugin_Runner_main.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Runner_main.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -25,9 +25,7 @@
 //  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>
@ -44,11 +42,11 @@
 */
 int main(int argc, char *argv[]){
-  if(argc!=8||(argc==2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help")==0))){
+  if(argc!=9||(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 << "Error in number of arguments "<< argc<<" given expected 8" <<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 << "           ELEM_ORIENT_FILE NB_THREADS" << 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;
@ -59,17 +57,19 @@ int main(int argc, char *argv[]){
    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 << "  NB_THREADS: Number of thread to use for the mesher" << 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;
+    return 0;
  }
  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];
+  int nbThreads=std::stoi(argv[6]);
-  std::string output_mesh_file=argv[7];
+  std::string new_element_file=argv[7];
  std::string output_mesh_file=argv[8];
  //std::string thing;
  //std::cin >> thing;
@ -80,46 +80,22 @@ int main(int argc, char *argv[]){
    element_orientation_file = "";
  if (new_element_file == "NONE")
    new_element_file = "";
-  int ret = 0;
+
  if (mesher=="NETGEN3D"){
    auto begin = std::chrono::high_resolution_clock::now();
    NETGENPlugin_NETGEN_3D_SA myplugin;
-    ret = myplugin.run(input_mesh_file,
+    myplugin.run(input_mesh_file,
             shape_file,
             hypo_file,
             element_orientation_file,
             new_element_file,
-             output_mesh_file );
+             output_mesh_file,
-  }
+             nbThreads);
-  else if ( mesher=="NETGEN1D" || 
+    auto end = std::chrono::high_resolution_clock::now();
-            mesher=="NETGEN1D2D" || 
+    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
-            mesher=="NETGEN1D2D3D" ) 
+    std::cout << "Time elapsed: " << elapsed.count()*1e-9 << std::endl;
-  {
+  } else {
    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;
+  return 0;
 }
--- a/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, 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 < 0 )
+  if ( nb < 1 )
    throw SALOME_Exception("Number of segments must be positive");
  if (nb != _nbSegments)
  {
--- a/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D_i.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D_i.hxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
--- a/src/NETGENPlugin/NETGENPlugin_i.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_i.cxx
@ -1,4 +1,4 @@
-// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -37,7 +37,6 @@
 #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"
@ -67,8 +66,6 @@ extern "C"
      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)
--- a/src/NETGENPlugin/init.py
+++ b/src/NETGENPlugin/init.py
@ -1,4 +1,4 @@
-# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+# Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
Author	SHA1	Message	Date
Yoann Audouin	3a6a1c7888	Cleanup of NETGEN_2D_Only	2022-09-28 08:06:51 +02:00
Yoann Audouin	4264181864	cout replaced by MESSAGE + clean up	2022-09-21 16:36:10 +02:00
Yoann Audouin	b3018b01b0	Removing hard coded meshname from Mesh import	2022-09-21 15:15:31 +02:00
Yoann Audouin	5e49461800	Creating Remote and SA NETGEN_3D plugins	2022-09-21 14:21:30 +02:00
Yoann Audouin	a52ccf7016	Refactoring of runner	2022-09-19 15:13:31 +02:00
Yoann Audouin	9ca5a5ccb4	Refactor in runner	2022-09-19 11:49:00 +02:00
Yoann Audouin	7b58079a8f	Refactoring of normal Compute	2022-09-19 11:18:08 +02:00
Yoann Audouin	f48857dd37	Now filling param _hypParameters and _stdMaxvolume	2022-09-19 11:15:26 +02:00
Yoann Audouin	9a8699d341	Adding support for BRep for shape	2022-09-15 15:12:50 +02:00
Yoann Audouin	f6f53b135d	Switchin to QProcess instead of sytem for remote compute	2022-09-15 14:06:22 +02:00
Yoann Audouin	75a1472981	Better handle of deletion of temporary folder + missing delete of temporary SMESH_Mesh	2022-09-15 11:01:41 +02:00
Yoann Audouin	01afecee31	Renaming functions and files + minor corrections in runner_main to detect what to do	2022-09-14 16:37:56 +02:00
Yoann Audouin	80e4ccd74d	Using RAII to remove file.close	2022-09-13 14:33:19 +02:00
Yoann Audouin	6859939db1	Adding support of number of thread for the mesher	2022-09-13 09:48:51 +02:00
Yoann Audouin	92df63b99d	Renaming netgen2d/3d internal calls	2022-09-12 08:11:15 +02:00
Yoann Audouin	9b35f0cc86	partial work for netgen2d in run_mesher + corrections for netgen3d nodeVec + restoring sequential netgen2D_only	2022-09-09 09:50:30 +02:00
Yoann Audouin	cd7fb05959	Generic path for executable	2022-08-31 16:29:01 +02:00
Yoann Audouin	c249924b3a	Integration of run_mesher code	2022-08-31 16:07:16 +02:00
Yoann Audouin	a90203eab4	restoring original compute + Cleanup	2022-08-31 09:34:02 +02:00
Yoann Audouin	6cd4dbe17e	Working version for run_mesher for netgen 3d	2022-08-26 11:36:21 +02:00
Yoann Audouin	58c0c7e37e	Using provider for occgeom and nglib	2022-07-25 10:34:43 +02:00