diff --git a/CHANGELOG b/CHANGELOG index 98476b5b0fa459e3664ac145b8d1a09a41665c51..7edc594e0ddf0beaeb8be6ead21042a96b4acfe6 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -23,18 +23,14 @@ Differences Between DuMuX 2.8 and DuMuX 2.9 * IMMEDIATE INTERFACE CHANGES not allowing/requiring a deprecation period: - For the multidomain models, the notation of the boundary condition types - has changed. This is especially important for all momentum boundary - conditions. In general: + has changed. This is especially important for all momentum boundary conditions. + In general: couplingInflow -> couplingNeumann couplingOutflow -> couplingDirichlet But for the momentum balances: couplingInflow -> couplingDirichlet couplingOutflow -> couplingNeumann - - The TypeTags "ImplicitModel" and "ExplicitModel" have been deleted. They - haven't been used apart from one internal inheritance. See FS#304 for - details. - * Deprecated PROPERTY and PARAMETER NAMES, to be removed after 2.9: BEWARE: The compiler will not print any warning if a deprecated property or parameter name is used. However, a run-time warning should appear in the summary lines after diff --git a/COPYING b/COPYING deleted file mode 120000 index f0c4298632f957385e61afc91647f6faeb78e804..0000000000000000000000000000000000000000 --- a/COPYING +++ /dev/null @@ -1 +0,0 @@ -LICENSE.md \ No newline at end of file diff --git a/COPYING b/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..1e1f3445db4b65aec98475d2b38aa31df40ac898 --- /dev/null +++ b/COPYING @@ -0,0 +1,400 @@ +Copyright holders: + +2010-2014 Katherina Baber +2015 Martin Beck +2013-2015 Beatrix Becker +2014 Markus Blatt +2010 Felix Bode +2007-2011 Yufei Cao +2011-2014 Holger Class +2008-2013 Melanie Darcis +2008-2009 Onur Dogan +2009-2011 Karin Erbertseder +2009-2014 Benjamin Faigle +2013-2015 Thomas Fetzer +2007-2015 Bernd Flemisch +2007-2010 Jochen Fritz +2012-2015 Christoph Grüninger +2015 Johannes Hommel +2012-2015 Vishal Jambhekar +2013-2014 Muhammad Adil Javed +2012-2015 Alexander Kissinger +2013-2015 Timo Koch +2008-2012 Andreas Lauser +2008-2014 Klaus Mosthaf +2009-2014 Philipp Nuske +2014 Mirka Papenheim +2013-2014 Dominik Riesterer +2008 Irina Rybak +2013-2015 Martin Schneider +2015 Simon Scholz +2009 Anneli Schöniger +2015 Natalie Schröder +2010-2015 Nicolas Schwenck +2015 Gabriele Seitz +2011 Michael Sinsbeck +2010 Leopold Stadler +2012-2014 Alexandru Tatomir +2013 Katharina Türk +2010-2014 Lena Walter +2015 Kilian Weishaupt +2010-2011 David Werner +2015 Hao Wu +2008-2013 Markus Wolff +2013 Tianyuan Zheng + +DuMuX is licensed under the terms and conditions of the GNU General +Public License (GPL) version 2 or - at your option - any later +version. The GPL can be read online [0], or below. + +Please note that DuMuX's license, unlike DUNE, does NOT feature a +template exception to the GNU General Public License. This means that +you must publish any source code which uses any of the DuMuX header +files if you want to redistribute your program to third parties. If +this is unacceptable to you, please contact us [1, 2] for a commercial +license. + +[0] http://www.gnu.org/licenses/old-licenses/gpl-2.0.html +[1] Bernd Flemisch +[2] http://www.hydrosys.uni-stuttgart.de/index.en.php + + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 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. + + 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 Lesser 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. + + + Copyright (C) + + 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., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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. + + , 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 Lesser General +Public License instead of this License. diff --git a/LICENSE.md b/LICENSE.md deleted file mode 100644 index 30884a30caf4a15489b8f68d8f66c594732422d3..0000000000000000000000000000000000000000 --- a/LICENSE.md +++ /dev/null @@ -1,412 +0,0 @@ -Licensing Information -===================== - -Copyright holders ------------------ - -| Year | Name | -|------------|----------------------------| -| 2010-2014 | Katherina Baber | -| 2015 | Martin Beck | -| 2013-2015 | Beatrix Becker | -| 2014 | Markus Blatt | -| 2010 | Felix Bode | -| 2007-2011 | Yufei Cao | -| 2011-2014 | Holger Class | -| 2008-2013 | Melanie Darcis | -| 2008-2009 | Onur Dogan | -| 2009-2011 | Karin Erbertseder | -| 2009-2014 | Benjamin Faigle | -| 2013-2015 | Thomas Fetzer | -| 2007-2015 | Bernd Flemisch | -| 2007-2010 | Jochen Fritz | -| 2012-2015 | Christoph Grüninger | -| 2015 | Johannes Hommel | -| 2012-2015 | Vishal Jambhekar | -| 2013-2014 | Muhammad Adil Javed | -| 2012-2015 | Alexander Kissinger | -| 2013-2015 | Timo Koch | -| 2008-2012 | Andreas Lauser | -| 2008-2014 | Klaus Mosthaf | -| 2009-2014 | Philipp Nuske | -| 2014 | Mirka Papenheim | -| 2013-2014 | Dominik Riesterer | -| 2008 | Irina Rybak | -| 2013-2015 | Martin Schneider | -| 2015 | Simon Scholz | -| 2009 | Anneli Schöniger | -| 2015 | Natalie Schröder | -| 2010-2015 | Nicolas Schwenck | -| 2015 | Gabriele Seitz | -| 2011 | Michael Sinsbeck | -| 2010 | Leopold Stadler | -| 2012-2014 | Alexandru Tatomir | -| 2013 | Katharina Türk | -| 2010-2014 | Lena Walter | -| 2015 | Kilian Weishaupt | -| 2010-2011 | David Werner | -| 2015 | Hao Wu | -| 2008-2013 | Markus Wolff | -| 2013 | Tianyuan Zheng | - - -License -------- - -DuMuX is licensed under the terms and conditions of the GNU General -Public License (GPL) version 2 or - at your option - any later -version. The GPL can be read online [0], or below. - -Please note that DuMuX' license, unlike DUNE's, does NOT feature a -template exception to the GNU General Public License. This means that -you must publish any source code which uses any of the DuMuX header -files if you want to redistribute your program to third parties. If -this is unacceptable to you, please [contact us][1] for a commercial -license. - -[0] http://www.gnu.org/licenses/old-licenses/gpl-2.0.html -[1] http://www.hydrosys.uni-stuttgart.de/index.en.php - - -Complete License Text ---------------------- - - GNU GENERAL PUBLIC LICENSE - Version 2, June 1991 - - Copyright (C) 1989, 1991 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. - - 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 Lesser 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. - - - Copyright (C) - - 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., - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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. - - , 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 Lesser General -Public License instead of this License. diff --git a/README b/README new file mode 100644 index 0000000000000000000000000000000000000000..3187412e0b77dc172f2b669f86fd0e6f7225cafe --- /dev/null +++ b/README @@ -0,0 +1,49 @@ +What is DUMUX? +============== + +DuMuX [0] is a simulation toolbox mainly aimed at flow and transport +processes in porous media. DuMuX is build on top of the DUNE [1] +framework and aims to provide a multitude of numerical models as well +as flexible discretization methods for complex non-linear phenomena, +such as CO2 sequestration, soil remediation, drug delivery in cancer +therapy and more. Multi-scale and multi-physics methods are currently +actively worked on. See [2] for a more detailed description of the +goals and motivations behind DuMuX. + + +INSTALLATION +============ + +Have a look at the installation guide [3] or use the DuMuXhandbook +[4], chapter 2. + + +LICENSE +======= + +DuMuX is licensed under the terms and conditions of the GNU General +Public License (GPL) version 2 or - at your option - any later +version. The GPL can be read online [5], or in the COPYING file +provided in the topmost directory of the DuMuX source code tree. + +Please note that DuMuX's license, unlike DUNE, does NOT feature a +template exception to the GNU General Public License. This means that +you must publish any source code which uses any of the DuMuX header +files if you want to redistribute your program to third parties. If +this is unacceptable to you, please contact us [6, 7] for a commercial +license. + +See the file COPYING for full copying permissions. + + +Links +===== + +[0] http://dumux.org +[1] http://dune-project.org +[2] http://dumux.org/documents/dumux_awrpaper.pdf +[3] http://www.dumux.org/installation.php +[4] http://www.dumux.org/documents/dumux-handbook-2.8.pdf +[5] http://www.gnu.org/licenses/old-licenses/gpl-2.0.html +[6] Bernd Flemisch +[7] http://www.hydrosys.uni-stuttgart.de/index.en.php diff --git a/README.md b/README.md deleted file mode 100644 index 2651b1fb3f859005954aca482fe24261eedf8c94..0000000000000000000000000000000000000000 --- a/README.md +++ /dev/null @@ -1,47 +0,0 @@ -Readme -====== - -What is DuMuX? --------------- - -[DuMuX][0] is a simulation toolbox mainly aimed at flow and transport -processes in porous media. DuMuX is build on top of the [DUNE][1] -framework and aims to provide a multitude of numerical models as well -as flexible discretization methods for complex non-linear phenomena, -such as CO2 sequestration, soil remediation, drug delivery in cancer -therapy and more. Multi-scale and multi-physics methods are currently -actively worked on. See [our publication][2] for a more detailed -description of the goals and motivations behind DuMuX. - - -Installation ------------- - -Have a look at the [installation guide][3] or use the [DuMuX handbook] -[4], chapter 2. - - -License -------- - -DuMuX is licensed under the terms and conditions of the GNU General -Public License (GPL) version 2 or - at your option - any later -version. The GPL can be [read online][5] or in the `LICENSE.md` file -provided in the topmost directory of the DuMuX source code tree. - -Please note that DuMuX' license, unlike DUNE's, does *not* feature a -template exception to the GNU General Public License. This means that -you must publish any source code which uses any of the DuMuX header -files if you want to redistribute your program to third parties. If -this is unacceptable to you, please [contact us][6] for a commercial -license. - -See the file `LICENSE.md` for full copying permissions. - -[0]: http://dumux.org -[1]: http://dune-project.org -[2]: http://dumux.org/documents/dumux_awrpaper.pdf -[3]: http://www.dumux.org/installation.php -[4]: http://www.dumux.org/documents/dumux-handbook-2.8.pdf -[5]: http://www.gnu.org/licenses/old-licenses/gpl-2.0.html -[6]: http://www.hydrosys.uni-stuttgart.de/index.en.php diff --git a/dumux/common/basicproperties.hh b/dumux/common/basicproperties.hh index e99725717581404cd20b0b0caa456b661b90839f..39dd19af28020e92f24aa0796c939a0781ad3f00 100644 --- a/dumux/common/basicproperties.hh +++ b/dumux/common/basicproperties.hh @@ -40,14 +40,29 @@ namespace Properties { /////////////////////////////////// // Type tag definitions: +// +// NumericModel +// | +// +-> ImplicitModel +// | +// \-> ExplicitModel /////////////////////////////////// //! Type tag for all models. NEW_TYPE_TAG(NumericModel); -///////////////////////////////////////////// +//! Type tag for all fully coupled models. +NEW_TYPE_TAG(ImplicitModel, INHERITS_FROM(NumericModel)); + +//! Type tag for all decoupled models. +NEW_TYPE_TAG(ExplicitModel, INHERITS_FROM(NumericModel)); + + +/////////////////////////////////// // Property names which are always available: -///////////////////////////////////////////// +// +// Scalar +/////////////////////////////////// //! Property to specify the type of scalar values. NEW_PROP_TAG(Scalar); @@ -94,6 +109,8 @@ NEW_PROP_TAG(VtkMultiWriter); /////////////////////////////////// // Default values for properties: +// +// Scalar -> double /////////////////////////////////// //! Set the default type of scalar values to double diff --git a/dumux/common/intersectionmapper.hh b/dumux/common/intersectionmapper.hh index 795a5b8100a40f7976e68d5c73554c86604373c3..4e0d07637a52117df5e50e70c1a24c56ef4dd27e 100644 --- a/dumux/common/intersectionmapper.hh +++ b/dumux/common/intersectionmapper.hh @@ -55,7 +55,7 @@ public: const auto element = *gridView_.template begin<0>(); int fIdx = 0; - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { int idxInInside = intersection.indexInInside(); @@ -198,13 +198,13 @@ public: intersectionMapLocal_.clear(); intersectionMapLocal_.resize(elementMapper_.size()); - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { int eIdxGlobal = index(element); int fIdx = 0; // run through all intersections with neighbors - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { int indexInInside = intersection.indexInInside(); intersectionMapLocal_[eIdxGlobal][fIdx] = indexInInside; @@ -214,13 +214,13 @@ public: } int globalIntersectionIdx = 0; - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { int eIdxGlobal = index(element); int fIdx = 0; // run through all intersections with neighbors - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { if (intersection.neighbor()) { @@ -237,7 +237,7 @@ public: } else { - for (const auto& intersectionNeighbor : Dune::intersections(gridView_, neighbor)) + for (const auto& intersectionNeighbor : intersections(gridView_, neighbor)) { if (intersectionNeighbor.neighbor()) { diff --git a/dumux/freeflow/stokes/localresidual.hh b/dumux/freeflow/stokes/localresidual.hh index e09ae9bb4719f558a1453adcd13366ab8126f414..cbe9c0825b996447c97584941e2c400a3fb5c122 100644 --- a/dumux/freeflow/stokes/localresidual.hh +++ b/dumux/freeflow/stokes/localresidual.hh @@ -352,7 +352,7 @@ protected: // evaluate boundary conditions for the intersections of // the current element const BoundaryTypes &bcTypes = this->bcTypes_(scvIdx); - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { // handle only intersections on the boundary if (!intersection.boundary()) diff --git a/dumux/freeflow/stokes/model.hh b/dumux/freeflow/stokes/model.hh index 0e96eb29e5f957f26b85fb529065c06a4562c39d..c430a35301217c682278f1074284371f6337fb1f 100644 --- a/dumux/freeflow/stokes/model.hh +++ b/dumux/freeflow/stokes/model.hh @@ -104,7 +104,7 @@ public: ElementVolumeVariables elemVolVars; // Loop over elements - for (const auto& element : Dune::elements(this->problem_.gridView())) + for (const auto& element : elements(this->problem_.gridView())) { if (element.partitionType() != Dune::InteriorEntity) continue; @@ -158,7 +158,7 @@ public: VolumeVariables volVars; ElementBoundaryTypes elemBcTypes; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int eIdx = this->elementMapper().index(element); diff --git a/dumux/freeflow/stokesnc/model.hh b/dumux/freeflow/stokesnc/model.hh index 58c6752c184af6f9196d4c23c96fd03b3298abdf..6d0c28882323e4ee3e66e8ab3db87028de33f751 100644 --- a/dumux/freeflow/stokesnc/model.hh +++ b/dumux/freeflow/stokesnc/model.hh @@ -132,7 +132,7 @@ public: VolumeVariables volVars; ElementBoundaryTypes elemBcTypes; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int idx = this->elementMapper().index(element); diff --git a/dumux/freeflow/stokesncni/model.hh b/dumux/freeflow/stokesncni/model.hh index 44ec850d24ed176193c148f708d34be42c03e003..7e5d83834db58842616b949a36bc6ca6e964cb59 100644 --- a/dumux/freeflow/stokesncni/model.hh +++ b/dumux/freeflow/stokesncni/model.hh @@ -139,7 +139,7 @@ public: VolumeVariables volVars; ElementBoundaryTypes elemBcTypes; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int idx = this->elementMapper().index(element); diff --git a/dumux/freeflow/zeroeq/model.hh b/dumux/freeflow/zeroeq/model.hh index 0ebd34a56591f7f209f751638e0316cd41ed720d..69b688bcc11dd2619987635f7d18aa10632ea36c 100644 --- a/dumux/freeflow/zeroeq/model.hh +++ b/dumux/freeflow/zeroeq/model.hh @@ -154,7 +154,7 @@ public: FVElementGeometry fvGeometry; VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int idx = this->elementMapper().index(element); rank[idx] = this->gridView_().comm().rank(); @@ -199,7 +199,7 @@ public: asImp_().writeFluxVarsHeader(fluxVarsFile); fluxVarsFile << std::endl; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); @@ -216,7 +216,7 @@ public: Scalar sumUPlus = 0.0; Scalar sumYPlus = 0.0; - for (const auto& intersection : Dune::intersections(this->gridView_(), element)) + for (const auto& intersection : intersections(this->gridView_(), element)) { int fIdx = intersection.indexInInside(); @@ -586,7 +586,7 @@ public: { FVElementGeometry fvGeometry; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); @@ -665,7 +665,7 @@ public: { FVElementGeometry fvGeometry; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); @@ -675,7 +675,7 @@ public: fvGeometry, false); - for (const auto& intersection : Dune::intersections(this->gridView_(), element)) + for (const auto& intersection : intersections(this->gridView_(), element)) { int fIdx = intersection.indexInInside(); FluxVariables fluxVars(this->problem_(), @@ -723,7 +723,7 @@ public: { FVElementGeometry fvGeometry; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); @@ -734,7 +734,7 @@ public: false); const ReferenceElement &refElement = ReferenceElements::general(element.geometry().type()); - for (const auto& intersection : Dune::intersections(this->gridView_(), element)) + for (const auto& intersection : intersections(this->gridView_(), element)) { // handle only faces on the boundary if (!intersection.boundary()) diff --git a/dumux/freeflow/zeroeqnc/model.hh b/dumux/freeflow/zeroeqnc/model.hh index 41b790ef3a010950f194c9281027f5b855892712..827e247ed6835caea0b53516e5f07adc4fae4064 100644 --- a/dumux/freeflow/zeroeqnc/model.hh +++ b/dumux/freeflow/zeroeqnc/model.hh @@ -161,7 +161,7 @@ public: ElementBoundaryTypes elemBcTypes; VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int idx = this->elementMapper().index(element); rank[idx] = this->gridView_().comm().rank(); @@ -227,7 +227,7 @@ public: asImp_().writeFluxVarsHeader(fluxFile); fluxFile << std::endl; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); @@ -245,7 +245,7 @@ public: Scalar sumYPlus = 0.0; Scalar sumEddyDiffusivity = 0.0; - for (const auto& intersection : Dune::intersections(this->gridView_(), element)) + for (const auto& intersection : intersections(this->gridView_(), element)) { int fIdx = intersection.indexInInside(); diff --git a/dumux/freeflow/zeroeqncni/model.hh b/dumux/freeflow/zeroeqncni/model.hh index 7cb238c38518328a88cf83c481e017155f9d7003..1e1cdb1d86f730491102b5217037773fecf64ec7 100644 --- a/dumux/freeflow/zeroeqncni/model.hh +++ b/dumux/freeflow/zeroeqncni/model.hh @@ -173,7 +173,7 @@ public: FVElementGeometry fvGeometry; VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int idx = this->elementMapper().index(element); rank[idx] = this->gridView_().comm().rank(); @@ -242,7 +242,7 @@ public: asImp_().writeFluxVarsHeader(fluxFile); fluxFile << std::endl; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); @@ -261,7 +261,7 @@ public: Scalar sumEddyDiffusivity = 0.0; Scalar sumEddyConducitivity = 0.0; - for (const auto& intersection : Dune::intersections(this->gridView_(), element)) + for (const auto& intersection : intersections(this->gridView_(), element)) { int fIdx = intersection.indexInInside(); diff --git a/dumux/geomechanics/el1p2c/model.hh b/dumux/geomechanics/el1p2c/model.hh index 1e5864d2a94a93ae307a425a8de47a6b1bac8928..5b95f634658e51a58e72a2cc566ecd9e086e84a7 100644 --- a/dumux/geomechanics/el1p2c/model.hh +++ b/dumux/geomechanics/el1p2c/model.hh @@ -246,7 +246,7 @@ public: // initialize start and end of element iterator // loop over all elements (cells) - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/geomechanics/el2p/amgbackend.hh b/dumux/geomechanics/el2p/amgbackend.hh index 1a8a04d6c76925f557ae13d4b9986cf6b751448f..bef3c01da03396c5aef81cf7d576ac389b96666b 100644 --- a/dumux/geomechanics/el2p/amgbackend.hh +++ b/dumux/geomechanics/el2p/amgbackend.hh @@ -99,7 +99,7 @@ private: // each vertex typedef std::set NeighborSet; std::vector neighbors(numVertices); - for (const auto& element : Dune::elements(this->problem().gridView())) { + for (const auto& element : elements(this->problem().gridView())) { // loop over all element vertices int n = element.subEntities(dim); diff --git a/dumux/geomechanics/el2p/assembler.hh b/dumux/geomechanics/el2p/assembler.hh index 61cae074891f3636ddf4e5e4b0b83a065fefe597..ca1daca18c0e7e14f786d39a89057d8d8342815c 100644 --- a/dumux/geomechanics/el2p/assembler.hh +++ b/dumux/geomechanics/el2p/assembler.hh @@ -320,7 +320,7 @@ public: }; // Mark all red elements - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { // find out whether the current element features a red // vertex bool isRed = false; @@ -343,7 +343,7 @@ public: } // Mark yellow vertices (as orange for the mean time) - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { int eIdx = this->elementMapper_().index(element); if (elementColor_[eIdx] != Red) continue; // non-red elements do not tint vertices @@ -360,7 +360,7 @@ public: } // Mark yellow elements - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { int eIdx = this->elementMapper_().index(element); if (elementColor_[eIdx] == Red) { continue; // element is red already! @@ -384,7 +384,7 @@ public: // Demote orange vertices to yellow ones if it has at least // one green element as a neighbor. - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { int eIdx = this->elementMapper_().index(element); if (elementColor_[eIdx] != Green) continue; // yellow and red elements do not make diff --git a/dumux/geomechanics/el2p/basemodel.hh b/dumux/geomechanics/el2p/basemodel.hh index e79afb3c6ee5bd22e52e559663f4fdff999f8e35..e65c1053b8d9e61918d879645ef19b05984d317a 100644 --- a/dumux/geomechanics/el2p/basemodel.hh +++ b/dumux/geomechanics/el2p/basemodel.hh @@ -242,7 +242,7 @@ public: { storage = 0; - for (const auto& element : Dune::elements(gridView_())) + for (const auto& element : elements(gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { @@ -836,7 +836,7 @@ protected: // // TODO: the initial condition needs to be unique for // each vertex. we should think about the API... - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { // deal with the current element fvGeometry.update(gridView_(), element); @@ -905,11 +905,11 @@ protected: boundaryIndices_.resize(numDofs()); std::fill(boundaryIndices_.begin(), boundaryIndices_.end(), false); - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { Dune::GeometryType geomType = element.geometry().type(); const ReferenceElement &refElement = ReferenceElements::general(geomType); - for (const auto& intersection : Dune::intersections(gridView_(), element)) { + for (const auto& intersection : intersections(gridView_(), element)) { if (intersection.boundary()) { if (isBox) { diff --git a/dumux/geomechanics/el2p/localoperator.hh b/dumux/geomechanics/el2p/localoperator.hh index 8903dcdf920e82ac075d8eec3411cdd6fafec29d..2dffdb42147a65022dba693eaa5c83fa558f0270 100644 --- a/dumux/geomechanics/el2p/localoperator.hh +++ b/dumux/geomechanics/el2p/localoperator.hh @@ -370,7 +370,7 @@ public: } // include boundary conditions // iterate over element intersections of codim dim-1 - for (const auto& intersection : Dune::intersections(model_.problem().gridView(), eg.entity())) + for (const auto& intersection : intersections(model_.problem().gridView(), eg.entity())) { // handle only faces on the boundary if (!intersection.boundary()) diff --git a/dumux/geomechanics/el2p/model.hh b/dumux/geomechanics/el2p/model.hh index 3bfdc6be6ca46f1c5e163dcc625a99b5108f9988..98a72cf4c26c019b24f721a4edf494dfc40ba95d 100644 --- a/dumux/geomechanics/el2p/model.hh +++ b/dumux/geomechanics/el2p/model.hh @@ -326,7 +326,7 @@ public: const typename GridFunctionSpace::Ordering& ordering = gridFunctionSpace.ordering(); // initialize start and end of element iterator // loop over all elements (cells) - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/geomechanics/elastic/model.hh b/dumux/geomechanics/elastic/model.hh index 96fdf270d994a40c467d7fc56153806b4d4324e6..58193a987f31b6abb9272f59518ccddd07b0f2df 100644 --- a/dumux/geomechanics/elastic/model.hh +++ b/dumux/geomechanics/elastic/model.hh @@ -118,7 +118,7 @@ public: VolumeVariables volVars; ElementBoundaryTypes elemBcTypes; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/implicit/adaptive/adaptionhelper.hh b/dumux/implicit/adaptive/adaptionhelper.hh index 9fb9be811cb741a537709c0093e7760642ef8178..8e390234404fc6d8a21383ab7f01e6968c5dccd7 100644 --- a/dumux/implicit/adaptive/adaptionhelper.hh +++ b/dumux/implicit/adaptive/adaptionhelper.hh @@ -125,7 +125,7 @@ public: if(!isBox) { - for (const auto& element : Dune::elements(levelView)) + for (const auto& element : elements(levelView)) { //get your map entry AdaptedValues &adaptedValues = adaptionMap_[element]; @@ -152,7 +152,7 @@ public: } else { - for (const auto& entity : Dune::entities(levelView, Dune::Codim())) + for (const auto& entity : entities(levelView, Dune::Codim())) { //get your map entry AdaptedValues &adaptedValues = adaptionMap_[entity]; @@ -190,7 +190,7 @@ public: { LevelGridView levelView = grid_.levelGridView(level); - for (const auto& element : Dune::elements(levelView)) + for (const auto& element : elements(levelView)) { // only treat non-ghosts, ghost data is communicated afterwards if (element.partitionType() == Dune::GhostEntity) diff --git a/dumux/implicit/adaptive/gridadapt.hh b/dumux/implicit/adaptive/gridadapt.hh index b2bc721fd328a04e455b8a058346a243a8e88b91..351adbf29e589e34b591101203bdedc0f8c69d6c 100644 --- a/dumux/implicit/adaptive/gridadapt.hh +++ b/dumux/implicit/adaptive/gridadapt.hh @@ -234,7 +234,7 @@ public: typedef std::unordered_map CoarsenMarkerType; CoarsenMarkerType coarsenMarker; - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // only mark non-ghost elements if (element.partitionType() != Dune::GhostEntity) @@ -342,7 +342,7 @@ private: bool checkNeighborsRefine_(const Element &element, int level = 1) { // this also refines the neighbor elements - for(const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for(const auto& intersection : intersections(problem_.gridView(), element)) { if(!intersection.neighbor()) continue; @@ -386,14 +386,14 @@ private: { // run through all cells done=true; - for (const auto& element : Dune::elements(leafGridView)) + for (const auto& element : elements(leafGridView)) { // only mark non-ghost elements if (element.partitionType() == Dune::GhostEntity) continue; // run through all neighbor-cells (intersections) - for (const auto& intersection : Dune::intersections(leafGridView, element)) + for (const auto& intersection : intersections(leafGridView, element)) { if(!intersection.neighbor()) continue; diff --git a/dumux/implicit/adaptive/gridadaptinitializationindicator.hh b/dumux/implicit/adaptive/gridadaptinitializationindicator.hh index 04e8d08625ad30432e446ae707e3ba63a15167d6..abf0076c17a6668437d746e85d8a3be864e4a4ce 100644 --- a/dumux/implicit/adaptive/gridadaptinitializationindicator.hh +++ b/dumux/implicit/adaptive/gridadaptinitializationindicator.hh @@ -209,7 +209,7 @@ public: // 1) calculate Indicator -> min, maxvalues // loop over all leaf elements - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int globalIdxI = problem_.elementMapper().index(element); @@ -251,7 +251,7 @@ public: if (indicatorVector_[globalIdxI] != refineCell && (refineAtDirichletBC_ || refineAtFluxBC_)) { // Calculate the boundary indicator for all boundary intersections - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (intersection.boundary()) { diff --git a/dumux/implicit/assembler.hh b/dumux/implicit/assembler.hh index 4689e94ea4890bd1227e823401c54902bc2ecae9..5a414bbde71a56fbc3240e9c5df5d438533fb757 100644 --- a/dumux/implicit/assembler.hh +++ b/dumux/implicit/assembler.hh @@ -483,7 +483,7 @@ protected: greenElems_ = 0; // reassemble the elements... - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { if (element.partitionType() == Dune::GhostEntity) { asImp_().assembleGhostElement_(element); diff --git a/dumux/implicit/box/assembler.hh b/dumux/implicit/box/assembler.hh index 35fb6b2a6281baac0fb4484436c11a3ede9647f9..2afef023667c38e8f06e401c6baf931b91d7b42c 100644 --- a/dumux/implicit/box/assembler.hh +++ b/dumux/implicit/box/assembler.hh @@ -92,7 +92,7 @@ private: } // Mark all red elements - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { // find out whether the current element features a red // vertex bool isRed = false; @@ -119,7 +119,7 @@ private: } // Mark yellow vertices (as orange for the mean time) - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { int eIdx = this->elementMapper_().index(element); if (this->elementColor_[eIdx] != ParentType::Red) @@ -150,7 +150,7 @@ private: Dune::ForwardCommunication); // Mark yellow elements - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { int eIdx = this->elementMapper_().index(element); if (this->elementColor_[eIdx] == ParentType::Red) { @@ -177,7 +177,7 @@ private: // Demote orange vertices to yellow ones if it has at least // one green element as a neighbor. - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { int eIdx = this->elementMapper_().index(element); if (this->elementColor_[eIdx] != ParentType::Green) @@ -231,7 +231,7 @@ private: // each vertex typedef std::set NeighborSet; std::vector neighbors(numVerticesGlobal); - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { int numVerticesLocal = element.subEntities(dim); // if the element is not in the interior or the process diff --git a/dumux/implicit/box/fvelementgeometry.hh b/dumux/implicit/box/fvelementgeometry.hh index 4a757ff7b46301d4fe3f3ad68368badbf86d7d1c..82446c27af7aff554436999cba1cce2e017daf10 100644 --- a/dumux/implicit/box/fvelementgeometry.hh +++ b/dumux/implicit/box/fvelementgeometry.hh @@ -951,7 +951,7 @@ public: } // end loop over edges / sub control volume faces // fill boundary face data: - for (const auto& intersection : Dune::intersections(gridView, element)) + for (const auto& intersection : intersections(gridView, element)) if (intersection.boundary()) { int fIdx = intersection.indexInInside(); diff --git a/dumux/implicit/box/intersectiontovertexbc.hh b/dumux/implicit/box/intersectiontovertexbc.hh index a5f10109d61cc5ede1b6ae807dc07dd3f8ffbcf1..077a3241930d68cfb2825384f7c7ee9400cbd23a 100644 --- a/dumux/implicit/box/intersectiontovertexbc.hh +++ b/dumux/implicit/box/intersectiontovertexbc.hh @@ -58,11 +58,11 @@ public: for (int vIdx = 0; vIdx < vertexBC.size(); vIdx++) vertexBC[vIdx].setAllNeumann(); - for (const auto& element : Dune::elements(problem.gridView())) { + for (const auto& element : elements(problem.gridView())) { Dune::GeometryType geomType = element.geometry().type(); const ReferenceElement &refElement = ReferenceElements::general(geomType); - for (const auto& intersection : Dune::intersections(problem.gridView(), element)) { + for (const auto& intersection : intersections(problem.gridView(), element)) { if (!intersection.boundary()) continue; diff --git a/dumux/implicit/box/localresidual.hh b/dumux/implicit/box/localresidual.hh index 118f679c78f6a0c56160d1b60c11b4526bbd7066..4b69761d836ed384918e3209c2c968a4abfbfdc5 100644 --- a/dumux/implicit/box/localresidual.hh +++ b/dumux/implicit/box/localresidual.hh @@ -113,7 +113,7 @@ protected: Dune::GeometryType geoType = this->element_().geometry().type(); const ReferenceElement &refElement = ReferenceElements::general(geoType); - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { // handle only faces on the boundary if (intersection.boundary()) { diff --git a/dumux/implicit/cellcentered/assembler.hh b/dumux/implicit/cellcentered/assembler.hh index bdfcc152952e73317bac12e84a6aa5db5eedc258..8619bc4870120b569fd0829795a918ede2f358a1 100644 --- a/dumux/implicit/cellcentered/assembler.hh +++ b/dumux/implicit/cellcentered/assembler.hh @@ -73,7 +73,7 @@ private: // mark the red elements and update the tolerance of the // linearization which actually will get achieved this->nextReassembleAccuracy_ = 0; - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { int eIdx = this->elementMapper_().index(element); if (this->delta_[eIdx] > relTol) @@ -91,7 +91,7 @@ private: } // mark the neighbors also red - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { int eIdx = this->elementMapper_().index(element); if (this->elementColor_[eIdx] == ParentType::Red) @@ -100,7 +100,7 @@ private: if (this->delta_[eIdx] > relTol) { // also mark the neighbors - for (const auto& intersection : Dune::intersections(this->gridView_(), element)) + for (const auto& intersection : intersections(this->gridView_(), element)) { if (intersection.neighbor()) { @@ -130,7 +130,7 @@ private: // each element typedef std::set NeighborSet; std::vector neighbors(numElements); - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { int globalI = this->elementMapper_().index(element); @@ -142,7 +142,7 @@ private: // continue; // loop over all neighbors - for (const auto& intersection : Dune::intersections(this->gridView_(), element)) + for (const auto& intersection : intersections(this->gridView_(), element)) { if (intersection.neighbor()) { @@ -207,7 +207,7 @@ private: (*this->matrix_)[globalI][globalI] = this->model_().localJacobian().mat(0,0); int j = 0; - for (const auto& intersection : Dune::intersections(this->gridView_(), element)) + for (const auto& intersection : intersections(this->gridView_(), element)) { if (intersection.neighbor()) { diff --git a/dumux/implicit/cellcentered/elementboundarytypes.hh b/dumux/implicit/cellcentered/elementboundarytypes.hh index c6248e9d1cb2f48524c1f8995a748fec78915224..90cf787b6e484c861f2c3491ee02ba552a9a3db8 100644 --- a/dumux/implicit/cellcentered/elementboundarytypes.hh +++ b/dumux/implicit/cellcentered/elementboundarytypes.hh @@ -89,7 +89,7 @@ public: if (!problem.model().onBoundary(element)) return; - for (const auto& intersection : Dune::intersections(problem.gridView(), element)) { + for (const auto& intersection : intersections(problem.gridView(), element)) { if (!intersection.boundary()) continue; diff --git a/dumux/implicit/cellcentered/elementvolumevariables.hh b/dumux/implicit/cellcentered/elementvolumevariables.hh index 54201aa19254261ef88a851089bca141922a2e1f..4710013f4b9bcca3003887bf22c061587fe2b039 100644 --- a/dumux/implicit/cellcentered/elementvolumevariables.hh +++ b/dumux/implicit/cellcentered/elementvolumevariables.hh @@ -105,7 +105,7 @@ public: this->resize(numNeighbors + element.subEntities(1)); // add volume variables for the boundary faces - for (const auto& intersection : Dune::intersections(problem.gridView(), element)) { + for (const auto& intersection : intersections(problem.gridView(), element)) { if (!intersection.boundary()) continue; diff --git a/dumux/implicit/cellcentered/fvelementgeometry.hh b/dumux/implicit/cellcentered/fvelementgeometry.hh index dcafd0a54b8aacd0d72fb2e3d9aa00ac07046f03..c69249454ab842c33a66a612431c0f9149ec89f7 100644 --- a/dumux/implicit/cellcentered/fvelementgeometry.hh +++ b/dumux/implicit/cellcentered/fvelementgeometry.hh @@ -129,7 +129,7 @@ public: bool onBoundary = false; // fill neighbor information and control volume face data: - for (const auto& intersection : Dune::intersections(gridView, element)) + for (const auto& intersection : intersections(gridView, element)) { const auto isGeometry = intersection.geometry(); diff --git a/dumux/implicit/cellcentered/localresidual.hh b/dumux/implicit/cellcentered/localresidual.hh index 3f361adc0e3ad0c53dc0e9c97ba24eb058d28cd9..2e4b094e12fd57d7ea772b297a36202b0b1f3e6b 100644 --- a/dumux/implicit/cellcentered/localresidual.hh +++ b/dumux/implicit/cellcentered/localresidual.hh @@ -72,7 +72,7 @@ protected: */ void evalBoundaryFluxes_() { - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { // handle only faces on the boundary if (!intersection.boundary()) @@ -101,7 +101,7 @@ protected: */ void evalDirichlet_() { - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { // handle only faces on the boundary if (!intersection.boundary()) @@ -265,7 +265,7 @@ protected: // calculate the mass flux over the faces and subtract // it from the local rates int fIdx = -1; - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) { + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { if (!intersection.neighbor()) continue; diff --git a/dumux/implicit/cornerpoint/elementvolumevariables.hh b/dumux/implicit/cornerpoint/elementvolumevariables.hh index 7a8da16acb31461fb644d89caf2d220d61d69997..383200e7e727466d22c795c0179cdd1450d61e4c 100644 --- a/dumux/implicit/cornerpoint/elementvolumevariables.hh +++ b/dumux/implicit/cornerpoint/elementvolumevariables.hh @@ -105,7 +105,7 @@ public: this->resize(numNeighbors + numFaces); // add volume variables for the boundary faces - for (const auto& intersection : Dune::intersections(problem.gridView(), element)) { + for (const auto& intersection : intersections(problem.gridView(), element)) { if (!intersection.boundary()) continue; diff --git a/dumux/implicit/cornerpoint/fvelementgeometry.hh b/dumux/implicit/cornerpoint/fvelementgeometry.hh index d25af5ec8182f763584cca4416d28013939dfdf9..f32af5f38ecae0520db9abd4021df0a415de81fd 100644 --- a/dumux/implicit/cornerpoint/fvelementgeometry.hh +++ b/dumux/implicit/cornerpoint/fvelementgeometry.hh @@ -127,7 +127,7 @@ public: bool onBoundary = false; // fill neighbor information and control volume face data: - for (const auto& intersection : Dune::intersections(gridView, element)) + for (const auto& intersection : intersections(gridView, element)) { const auto isGeometry = intersection.geometry(); diff --git a/dumux/implicit/model.hh b/dumux/implicit/model.hh index 8b15f6144dab7959056a6e3ca29bfeeec654a101..a7ef850f6c976846414e5cfd0c354b8fce1d49b9 100644 --- a/dumux/implicit/model.hh +++ b/dumux/implicit/model.hh @@ -223,7 +223,7 @@ public: { residual = 0; - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { localResidual().eval(element); if (isBox) @@ -268,7 +268,7 @@ public: { storage = 0; - for (const auto& element : Dune::elements(gridView_())) + for (const auto& element : elements(gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { @@ -902,7 +902,7 @@ protected: // // TODO: the initial condition needs to be unique for // each vertex. we should think about the API... - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { // deal with the current element fvGeometry.update(gridView_(), element); @@ -971,11 +971,11 @@ protected: boundaryIndices_.resize(numDofs()); std::fill(boundaryIndices_.begin(), boundaryIndices_.end(), false); - for (const auto& element : Dune::elements(gridView_())) { + for (const auto& element : elements(gridView_())) { Dune::GeometryType geomType = element.geometry().type(); const ReferenceElement &refElement = ReferenceElements::general(geomType); - for (const auto& intersection : Dune::intersections(gridView_(), element)) { + for (const auto& intersection : intersections(gridView_(), element)) { if (intersection.boundary()) { if (isBox) { diff --git a/dumux/implicit/problem.hh b/dumux/implicit/problem.hh index 2aa443a17d418bea7bb3c1bc47b500a430446fde..1a208cf7ce30f4228a634152b1962babcb39fc61 100644 --- a/dumux/implicit/problem.hh +++ b/dumux/implicit/problem.hh @@ -109,7 +109,7 @@ public: , newtonCtl_(asImp_()) { // calculate the bounding box of the local partition of the grid view - for (const auto& vertex : Dune::vertices(gridView)) { + for (const auto& vertex : vertices(gridView)) { for (int i=0; i())) { + for (const auto& entity : entities(gridView, Dune::Codim())) { serializer.serializeEntity(outStream_, entity); outStream_ << "\n"; } @@ -253,7 +253,7 @@ public: std::string curLine; // read entity data - for (const auto& entity : Dune::entities(gridView, Dune::Codim())) { + for (const auto& entity : entities(gridView, Dune::Codim())) { if (!inStream_.good()) { DUNE_THROW(Dune::IOError, "Restart file is corrupted"); diff --git a/dumux/linear/amgparallelhelpers.hh b/dumux/linear/amgparallelhelpers.hh index 33ce909f7d177e7342aeb90ec61991cdab96e037..80a65acdc8728b99dc45a4b42b566d044e2f275a 100644 --- a/dumux/linear/amgparallelhelpers.hh +++ b/dumux/linear/amgparallelhelpers.hh @@ -511,7 +511,7 @@ public: const GridView& gridView = problem.gridView(); - for (const auto& entity : Dune::entities(gridView, Dune::Codim())) + for (const auto& entity : entities(gridView, Dune::Codim())) { if (entity.partitionType() == Dune::BorderEntity) { diff --git a/dumux/multidomain/2cnistokes2p2cni/2p2cnicouplinglocalresidual.hh b/dumux/multidomain/2cnistokes2p2cni/2p2cnicouplinglocalresidual.hh index b8b1df939fca87e111956d77e2ff6ff9338549ad..be851508dd0afca5fd956010104477b86814766d 100644 --- a/dumux/multidomain/2cnistokes2p2cni/2p2cnicouplinglocalresidual.hh +++ b/dumux/multidomain/2cnistokes2p2cni/2p2cnicouplinglocalresidual.hh @@ -103,7 +103,7 @@ public: continue; // evaluate boundary conditions for the intersections of the current element - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { // handle only intersections on the boundary if (!intersection.boundary()) diff --git a/dumux/multidomain/2cnistokes2p2cni/stokesncnicouplinglocalresidual.hh b/dumux/multidomain/2cnistokes2p2cni/stokesncnicouplinglocalresidual.hh index 52bb8793a6e223e3a3ab4f8e854c4fb8528166fd..468048d04369d9a91860a80d77c32331fcc14782 100644 --- a/dumux/multidomain/2cnistokes2p2cni/stokesncnicouplinglocalresidual.hh +++ b/dumux/multidomain/2cnistokes2p2cni/stokesncnicouplinglocalresidual.hh @@ -107,7 +107,7 @@ public: const BoundaryTypes &bcTypes = this->bcTypes_(scvIdx); // evaluate boundary conditions for the intersections of the current element - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { // handle only intersections on the boundary if (!intersection.boundary()) diff --git a/dumux/multidomain/2cstokes2p2c/2p2ccouplinglocalresidual.hh b/dumux/multidomain/2cstokes2p2c/2p2ccouplinglocalresidual.hh index 69f154653a9716004f6e48d7cc4a04fbf2081af5..2ed3755b6082603b38652c3a4f6c8c0d53c2071c 100644 --- a/dumux/multidomain/2cstokes2p2c/2p2ccouplinglocalresidual.hh +++ b/dumux/multidomain/2cstokes2p2c/2p2ccouplinglocalresidual.hh @@ -103,7 +103,7 @@ public: continue; // evaluate boundary conditions for the intersections of the current element - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { // handle only intersections on the boundary if (!intersection.boundary()) diff --git a/dumux/multidomain/2cstokes2p2c/stokesnccouplinglocalresidual.hh b/dumux/multidomain/2cstokes2p2c/stokesnccouplinglocalresidual.hh index b4a9154875946af7b346439f990dcc6488a86ebc..bfa130aa15ac3711b16c41530e6517aa81a2f78d 100644 --- a/dumux/multidomain/2cstokes2p2c/stokesnccouplinglocalresidual.hh +++ b/dumux/multidomain/2cstokes2p2c/stokesnccouplinglocalresidual.hh @@ -118,7 +118,7 @@ public: const BoundaryTypes &bcTypes = this->bcTypes_(scvIdx); // evaluate boundary conditions for the intersections of the current element - for (const auto& intersection : Dune::intersections(this->gridView_(), this->element_())) + for (const auto& intersection : intersections(this->gridView_(), this->element_())) { // handle only intersections on the boundary if (!intersection.boundary()) diff --git a/dumux/porousmediumflow/1p/implicit/model.hh b/dumux/porousmediumflow/1p/implicit/model.hh index 27878b7e11a44c1502e0772f0aa8a16099718ff2..fa027873425a1f3320e97639d4b29c32e3b7b80b 100644 --- a/dumux/porousmediumflow/1p/implicit/model.hh +++ b/dumux/porousmediumflow/1p/implicit/model.hh @@ -101,7 +101,7 @@ public: unsigned numElements = this->gridView_().size(0); ScalarField *rank = writer.allocateManagedBuffer(numElements); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/porousmediumflow/1p/sequential/diffusion/cellcentered/velocity.hh b/dumux/porousmediumflow/1p/sequential/diffusion/cellcentered/velocity.hh index 8f3610329bbcfde266d91114e3b9c8f6bed67dcd..eaf903ec20c8e5e51854694eb26d90f0b55c068d 100644 --- a/dumux/porousmediumflow/1p/sequential/diffusion/cellcentered/velocity.hh +++ b/dumux/porousmediumflow/1p/sequential/diffusion/cellcentered/velocity.hh @@ -112,7 +112,7 @@ public: problem_.gridView().size(0))); // compute update vector - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobal = problem_.variables().index(element); @@ -129,7 +129,7 @@ public: std::vector flux(numberOfFaces,0); // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int isIndex = intersection.indexInInside(); diff --git a/dumux/porousmediumflow/1p2c/implicit/model.hh b/dumux/porousmediumflow/1p2c/implicit/model.hh index f8d8a9fad7b846caed83e2c1bc64faab72a1942a..edfa45fe0691ea83048af081b3d85066480c4db1 100644 --- a/dumux/porousmediumflow/1p2c/implicit/model.hh +++ b/dumux/porousmediumflow/1p2c/implicit/model.hh @@ -129,7 +129,7 @@ public: unsigned numElements = this->gridView_().size(0); ScalarField &rank = *writer.allocateManagedBuffer(numElements); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/porousmediumflow/2p/implicit/gridadaptindicator.hh b/dumux/porousmediumflow/2p/implicit/gridadaptindicator.hh index 89f8b80233313e67231fb30ae31f26c7568281dd..70faf4e2dee7bf85d23c96688e5ecadcd31b318a 100644 --- a/dumux/porousmediumflow/2p/implicit/gridadaptindicator.hh +++ b/dumux/porousmediumflow/2p/implicit/gridadaptindicator.hh @@ -90,7 +90,7 @@ public: // 1) calculate Indicator -> min, maxvalues // loop over all leaf-elements - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // calculate minimum and maximum saturation // index of the current leaf-elements @@ -122,7 +122,7 @@ public: globalMax = std::max(satI, globalMax); // calculate refinement indicator in all cells - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { // Only consider internal intersections if (intersection.neighbor()) diff --git a/dumux/porousmediumflow/2p/implicit/model.hh b/dumux/porousmediumflow/2p/implicit/model.hh index 418ec905b6ce4a6864ca7e9482b67cb1021ea9cb..024e032b46d5828d5c1a7fcf750df862d75386dc 100644 --- a/dumux/porousmediumflow/2p/implicit/model.hh +++ b/dumux/porousmediumflow/2p/implicit/model.hh @@ -138,7 +138,7 @@ public: unsigned numElements = this->gridView_().size(0); ScalarField *rank = writer.allocateManagedBuffer(numElements); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/pressure.hh b/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/pressure.hh index 66a35159e4e76bcc25149d576a8998f0bc2ba35b..89c04798f33bb39f67346d5c35efafa909cbdd18 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/pressure.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/pressure.hh @@ -301,7 +301,7 @@ public: void storePressureSolution() { // iterate through leaf grid - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { asImp_().storePressureSolution(element); } @@ -1060,7 +1060,7 @@ const Intersection& intersection, const CellData& cellData, const bool first) template void FVPressure2P::updateMaterialLaws() { - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/pressureadaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/pressureadaptive.hh index fc800e29d0ddfcd8bdfb833823cfa6f9ecacdea5..0a8bf5a15a2fd7153387965706f7280831d610c4 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/pressureadaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/pressureadaptive.hh @@ -304,7 +304,7 @@ void FVPressure2PAdaptive::getFlux(EntryType& entry, const Intersection // IsIndexJ, the index of the interface from the neighbor-cell point of view // GlobalIdxK, the index of the third cell // Intersectioniterator around cell I - for (const auto& intersectionI : Dune::intersections(problem_.gridView(), elementI)) + for (const auto& intersectionI : intersections(problem_.gridView(), elementI)) { if (intersectionI.neighbor()) { diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/velocity.hh b/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/velocity.hh index 794767082692be4db500c21b4fdc13c6713d6ac4..5a66c5516ea5c58bf5aee4a68c9df79ca1250faf 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/velocity.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/velocity.hh @@ -188,7 +188,7 @@ public: *(writer.template allocateManagedBuffer(problem_.gridView().size(0))); // compute update vector - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobal = problem_.variables().index(element); @@ -206,7 +206,7 @@ public: std::vector fluxNw(numberOfFaces,0); // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int isIndex = intersection.indexInInside(); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/velocityadaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/velocityadaptive.hh index 3b7541d1b963e51a49696a9196464beb3898e38c..f3407c4bfd6c27af1a7fd14c583a048c4c6a93b9 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/velocityadaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/cellcentered/velocityadaptive.hh @@ -207,7 +207,7 @@ void FVVelocity2PAdaptive::calculateVelocity(const Intersection& inters // for efficienty this is done in one intersection loop // Intersectioniterator around cell I - for (const auto& intersectionI : Dune::intersections(problem_.gridView(), elementI)) + for (const auto& intersectionI : intersections(problem_.gridView(), elementI)) { if (intersectionI.neighbor()) { diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/croperator.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/croperator.hh index b2af47a476a8eab698b4e2ada017f6c70a372bb7..cdd1c40c79eeecf8c1d905cda6e6a1724d428b52 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/croperator.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/croperator.hh @@ -132,7 +132,7 @@ public: std::vector visited(size_, false); // LOOP 1 : Compute row sizes - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { int numFaces = element.subEntities(1); @@ -159,7 +159,7 @@ public: visited.assign(size_, false); // LOOP 2 : insert the nonzeros - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { int numFaces = element.subEntities(1); @@ -248,7 +248,7 @@ public: Dune::FieldVector local2Global(0); // run over all leaf elements - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { unsigned int numFaces = element.subEntities(1); @@ -285,7 +285,7 @@ public: } } // run over all leaf elements - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { unsigned int numFaces = element.subEntities(1); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/croperatoradaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/croperatoradaptive.hh index 4f87a2d7d6823b78280dfdfc2cd1287c3373ee0d..769875020d8c03b8d3d9e2ecd7a321ad45ac6177 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/croperatoradaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/croperatoradaptive.hh @@ -263,7 +263,7 @@ void CROperatorAssemblerTwoPAdaptive::assemble(LocalStiffness& loc, Vec std::vector local2Global(2*dim); // run over all leaf elements - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { // build local stiffness matrix for CR elements // inludes rhs and boundary condition information @@ -302,7 +302,7 @@ void CROperatorAssemblerTwoPAdaptive::assemble(LocalStiffness& loc, Vec } // run over all leaf elements - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { int eIdxGlobal = intersectionMapper_.index(element); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/mimetic.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/mimetic.hh index 2706c0019df5b7c6e9a8ec5e680252824faece61..9c470abe7451b6219336f6d087a9cc7095f15a02 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/mimetic.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/mimetic.hh @@ -268,7 +268,7 @@ public: int eIdxGlobal = problem_.variables().index(element); Dune::FieldVector faceVol(0); - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { faceVol[intersection.indexInInside()] = intersection.geometry().volume(); } @@ -285,7 +285,7 @@ public: int eIdxGlobal = problem_.variables().index(element); Dune::FieldVector faceVol(0); - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { faceVol[intersection.indexInInside()] = intersection.geometry().volume(); } @@ -302,7 +302,7 @@ public: Dune::FieldVector c(0); Dune::FieldMatrix Pi(0); - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { // local number of facet int idx = intersection.indexInInside(); @@ -471,7 +471,7 @@ void MimeticTwoPLocalStiffness::assembleElementMatrices(const Element& Scalar gravPot = (problem_.bBoxMax() - centerGlobal) * problem_.gravity() * (density_[nPhaseIdx] - density_[wPhaseIdx]); - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { // local number of facet int fIdx = intersection.indexInInside(); @@ -606,7 +606,7 @@ void MimeticTwoPLocalStiffness::assembleElementMatrices(const Element& // std::cout << "Pi = \dim" << Pi << "c = " << c << ", F = " << F << std::endl; //accumulate fluxes due to capillary potential (pc + gravity!) - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { int idx = intersection.indexInInside(); @@ -707,7 +707,7 @@ template void MimeticTwoPLocalStiffness::assembleBC(const Element& element, int k) { // evaluate boundary conditions via intersection iterator - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { int faceIndex = intersection.indexInInside(); if (intersection.boundary()) diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/mimeticadaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/mimeticadaptive.hh index ae95ed75eb38f4d067e9f3e7b05d2c99925a3c1f..c5673496670f7601b939584b0144d4750941147f 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/mimeticadaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/mimeticadaptive.hh @@ -294,7 +294,7 @@ public: Dune::FieldVector faceVolumeReal(0.0); int idx = 0; - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { faceVol[idx] = intersection.geometry().volume(); int indexInInside = intersection.indexInInside(); @@ -326,7 +326,7 @@ public: Dune::DynamicMatrix Pi(numFaces, numFaces); int idx = 0; - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { Scalar faceVol = intersection.geometry().volume(); @@ -494,7 +494,7 @@ void MimeticTwoPLocalStiffnessAdaptive::assembleElementMatrices(const E * (density_[nPhaseIdx] - density_[wPhaseIdx]); int idx = 0; - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { // local number of facet @@ -635,7 +635,7 @@ void MimeticTwoPLocalStiffnessAdaptive::assembleElementMatrices(const E //accumulate fluxes due to capillary potential (pc + gravity!) idx = 0; - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { Scalar fracFlow = 0; @@ -735,7 +735,7 @@ void MimeticTwoPLocalStiffnessAdaptive::assembleBC(const Element& eleme { // evaluate boundary conditions via an intersection loop unsigned int faceIndex = 0; - for (const auto& intersection : Dune::intersections(gridView_, element)) + for (const auto& intersection : intersections(gridView_, element)) { if (intersection.neighbor()) { diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/operator.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/operator.hh index 2930af5881f4be147e1c63cfddf2c9ba8e0d2292..bb812b1e06fc2fdb2459fca5689e58a42e0bc46b 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/operator.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/operator.hh @@ -117,7 +117,7 @@ public: } // run over all level elements - for (const auto& element : Dune::elements(this->gridView_)) + for (const auto& element : elements(this->gridView_)) { int eIdxGlobal = problem.variables().index(element); @@ -125,7 +125,7 @@ public: FieldVector globalPos = element.geometry().center(); // get local to global id map and pressure traces - for (const auto& intersection : Dune::intersections(problem.gridView(), element)) + for (const auto& intersection : intersections(problem.gridView(), element)) { int indexInInside = intersection.indexInInside(); @@ -201,7 +201,7 @@ public: } } - for (const auto& intersection : Dune::intersections(problem.gridView(), element)) + for (const auto& intersection : intersections(problem.gridView(), element)) { int idxInInside = intersection.indexInInside(); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/operatoradaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/operatoradaptive.hh index d27585e740e441ce2f048b7c29ccc4430e801129..97ab748a3cd416ed49bd6a118d7da55400b870ee 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/operatoradaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/operatoradaptive.hh @@ -116,7 +116,7 @@ public: } // run over all level elements - for (const auto& element : Dune::elements(this->gridView_)) + for (const auto& element : elements(this->gridView_)) { int eIdxGlobal = problem.variables().index(element); @@ -133,7 +133,7 @@ public: int intersectionIdx = -1; // get local to global id map and pressure traces - for (const auto& intersection : Dune::intersections(problem.gridView(), element)) + for (const auto& intersection : intersections(problem.gridView(), element)) { ++intersectionIdx; @@ -208,7 +208,7 @@ public: loc.constructVelocity(element, velocityNw, pressTraceNw, cellData.potential(nPhaseIdx)); intersectionIdx = -1; - for (const auto& intersection : Dune::intersections(problem.gridView(), element)) + for (const auto& intersection : intersections(problem.gridView(), element)) { ++intersectionIdx; int idxInInside = intersection.indexInInside(); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/pressure.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/pressure.hh index af656edd93122bb53616685681ee2668953843d0..0ce383f91b7990e5b15a6ec5fec823ce98da4d43 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/pressure.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/pressure.hh @@ -241,7 +241,7 @@ public: } - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); CellData& cellData = problem_.variables().cellData(eIdxGlobal); @@ -284,7 +284,7 @@ public: std::vector fluxNw(numberOfFaces,0); // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int isIndex = intersection.indexInInside(); @@ -485,7 +485,7 @@ template void MimeticPressure2P::updateMaterialLaws() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/pressureadaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/pressureadaptive.hh index 00341c67d14693e0d92256090e03bb123bf8a793..7c0e3b8e305036e4de217d080bcd6eef972bd877 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/pressureadaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mimetic/pressureadaptive.hh @@ -253,7 +253,7 @@ public: } - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); CellData& cellData = problem_.variables().cellData(eIdxGlobal); @@ -296,7 +296,7 @@ public: std::vector fluxNw(numberOfFaces,0); // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int isIndex = intersection.indexInInside(); @@ -497,7 +497,7 @@ template void MimeticPressure2PAdaptive::updateMaterialLaws() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressure.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressure.hh index 5ed4fedfd9b58d98bfe6d8f684c9ad99f4e78e4b..9c3444e5ef65ba2287cbdaec4b4ab7bc3714ad99 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressure.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressure.hh @@ -225,7 +225,7 @@ public: */ void storePressureSolution() { - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { storePressureSolution(element); } @@ -360,7 +360,7 @@ public: ScalarSolutionType *potentialSecond = writer.allocateManagedBuffer(size); ScalarSolutionType *pc = writer.allocateManagedBuffer(size); - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int idx = problem_.variables().index(element); CellData& cellData = problem_.variables().cellData(idx); @@ -578,7 +578,7 @@ template void FvMpfaL2dPressure2p::initializeMatrix() { // determine matrix row sizes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -600,9 +600,9 @@ void FvMpfaL2dPressure2p::initializeMatrix() if (intersection.neighbor() && nextIntersection.neighbor()) { for (const auto& innerIntersection - : Dune::intersections(problem_.gridView(), intersection.outside())) + : intersections(problem_.gridView(), intersection.outside())) for (const auto& innerNextIntersection - : Dune::intersections(problem_.gridView(), nextIntersection.outside())) + : intersections(problem_.gridView(), nextIntersection.outside())) { if (innerIntersection.neighbor() && innerNextIntersection.neighbor()) { @@ -625,7 +625,7 @@ void FvMpfaL2dPressure2p::initializeMatrix() this->A_.endrowsizes(); // determine position of matrix entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -653,9 +653,9 @@ void FvMpfaL2dPressure2p::initializeMatrix() if (intersection.neighbor() && nextIntersection.neighbor()) { for (const auto& innerIntersection - : Dune::intersections(problem_.gridView(), intersection.outside())) + : intersections(problem_.gridView(), intersection.outside())) for (const auto& innerNextIntersection - : Dune::intersections(problem_.gridView(), nextIntersection.outside())) + : intersections(problem_.gridView(), nextIntersection.outside())) { if (innerIntersection.neighbor() && innerNextIntersection.neighbor()) { @@ -707,7 +707,7 @@ void FvMpfaL2dPressure2p::storeInteractionVolumeInfo() BoundaryTypes bcType; // run through all elements - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get common geometry information for the following computation @@ -843,12 +843,12 @@ void FvMpfaL2dPressure2p::storeInteractionVolumeInfo() GlobalPosition globalPosFace34(0); for (const auto& intersection23 - : Dune::intersections(problem_.gridView(), element2)) + : intersections(problem_.gridView(), element2)) { bool finished = false; for (const auto& intersection43 - : Dune::intersections(problem_.gridView(), element4)) + : intersections(problem_.gridView(), element4)) { if (intersection23.neighbor() && intersection43.neighbor()) { @@ -946,7 +946,7 @@ void FvMpfaL2dPressure2p::storeInteractionVolumeInfo() bool finished = false; for (const auto& intersection2 - : Dune::intersections(problem_.gridView(), element2)) + : intersections(problem_.gridView(), element2)) { if (intersection2.boundary()) { @@ -1077,7 +1077,7 @@ void FvMpfaL2dPressure2p::storeInteractionVolumeInfo() // get the information of the face 'isIt34' between cell3 and cell4 (locally numbered) for (const auto& intersection4 - : Dune::intersections(problem_.gridView(), element4)) + : intersections(problem_.gridView(), element4)) { if (intersection4.boundary()) { @@ -1164,7 +1164,7 @@ void FvMpfaL2dPressure2p::assemble() this->f_ = 0; // run through all vertices - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); @@ -1803,7 +1803,7 @@ void FvMpfaL2dPressure2p::assemble() if (problem_.gridView().comm().size() > 1) { // set ghost and overlap element entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { if (element.partitionType() == Dune::InteriorEntity) continue; @@ -1828,7 +1828,7 @@ template void FvMpfaL2dPressure2p::updateMaterialLaws() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressureadaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressureadaptive.hh index 2ab367aaafafcd3f7cf2dd01ed79b56f43d665ea..aa48172cd7ebe23f738e25f41747b639560192b5 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressureadaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressureadaptive.hh @@ -232,7 +232,7 @@ public: void storePressureSolution() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { storePressureSolution(element); } @@ -394,7 +394,7 @@ public: ScalarSolutionType *potentialSecond = writer.allocateManagedBuffer(size); ScalarSolutionType *pc = writer.allocateManagedBuffer(size); - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int idx = problem_.variables().index(element); CellData& cellData = problem_.variables().cellData(idx); @@ -582,7 +582,7 @@ template void FvMpfaL2dPressure2pAdaptive::initializeMatrix() { // determine matrix row sizes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -607,10 +607,10 @@ void FvMpfaL2dPressure2pAdaptive::initializeMatrix() bool isCorner = true; for (const auto& innerIntersection - : Dune::intersections(problem_.gridView(), intersection.outside())) + : intersections(problem_.gridView(), intersection.outside())) { for (const auto& innerNextIntersection - : Dune::intersections(problem_.gridView(), nextIntersection.outside())) + : intersections(problem_.gridView(), nextIntersection.outside())) { if (innerIntersection.neighbor() && innerNextIntersection.neighbor()) { @@ -646,7 +646,7 @@ void FvMpfaL2dPressure2pAdaptive::initializeMatrix() // indicate that size of all rows is defined this->A_.endrowsizes(); // determine position of matrix entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -686,10 +686,10 @@ void FvMpfaL2dPressure2pAdaptive::initializeMatrix() } for (const auto& innerIntersection - : Dune::intersections(problem_.gridView(), intersection.outside())) + : intersections(problem_.gridView(), intersection.outside())) { for (const auto& innerNextIntersection - : Dune::intersections(problem_.gridView(), nextIntersection.outside())) + : intersections(problem_.gridView(), nextIntersection.outside())) { if (innerIntersection.neighbor() && innerNextIntersection.neighbor()) { @@ -761,7 +761,7 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() BoundaryTypes bcType; // run through all elements - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get index int eIdxGlobal1 = problem_.variables().index(element); @@ -899,11 +899,11 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() bool isHangingNode = false; for (const auto& intersection2 - : Dune::intersections(problem_.gridView(), element2)) + : intersections(problem_.gridView(), element2)) { bool breakLoop = false; for (const auto& intersection4 - : Dune::intersections(problem_.gridView(), element4)) + : intersections(problem_.gridView(), element4)) { if (intersection2.neighbor() && intersection4.neighbor()) { @@ -974,10 +974,10 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() bool regularNode = false; for (const auto& intersection2 - : Dune::intersections(problem_.gridView(), element2)) + : intersections(problem_.gridView(), element2)) { for (const auto& intersection4 - : Dune::intersections(problem_.gridView(), element4)) + : intersections(problem_.gridView(), element4)) { if (intersection4.neighbor()) { @@ -1039,7 +1039,7 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() if (element32.level() > element2.level()) { for (const auto& intersection3 - : Dune::intersections(problem_.gridView(), element32)) + : intersections(problem_.gridView(), element32)) { if (intersection3.neighbor()) { @@ -1064,7 +1064,7 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() if (element34.level() > element4.level()) { for (const auto& intersection3 - : Dune::intersections(problem_.gridView(), element34)) + : intersections(problem_.gridView(), element34)) { if (intersection3.neighbor()) { @@ -1108,10 +1108,10 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() { bool regularNode = false; for (const auto& intersection2 - : Dune::intersections(problem_.gridView(), element2)) + : intersections(problem_.gridView(), element2)) { for (const auto& intersection4 - : Dune::intersections(problem_.gridView(), element4)) + : intersections(problem_.gridView(), element4)) { if (intersection4.neighbor()) { @@ -1229,7 +1229,7 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() finished = false; for (const auto& intersection2 - : Dune::intersections(problem_.gridView(), element2)) + : intersections(problem_.gridView(), element2)) { if (intersection2.boundary()) { @@ -1462,7 +1462,7 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() // get the information of the face 'isIt34' between cell3 and cell4 (locally numbered) for (const auto& intersection4 - : Dune::intersections(problem_.gridView(), element4)) + : intersections(problem_.gridView(), element4)) { if (intersection4.boundary()) { @@ -1553,7 +1553,7 @@ void FvMpfaL2dPressure2pAdaptive::storeInteractionVolumeInfo() template void FvMpfaL2dPressure2pAdaptive::printInteractionVolumes() { - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); @@ -1607,7 +1607,7 @@ void FvMpfaL2dPressure2pAdaptive::assemble() this->f_ = 0; // run through all vertices - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); @@ -2514,7 +2514,7 @@ void FvMpfaL2dPressure2pAdaptive::assemble() if (problem_.gridView().comm().size() > 1) { // set ghost and overlap element entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { if (element.partitionType() == Dune::InteriorEntity) continue; @@ -2539,7 +2539,7 @@ template void FvMpfaL2dPressure2pAdaptive::updateMaterialLaws() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressurevelocity.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressurevelocity.hh index c603bf6de8fc01bbaea127d62479b8b6373b3540..ad986141b2f085b7fafacf3216e9f1e662179f69 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressurevelocity.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressurevelocity.hh @@ -218,7 +218,7 @@ template void FvMpfaL2dPressureVelocity2p::calculateVelocity() { // run through all elements - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressurevelocityadaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressurevelocityadaptive.hh index 9efa28a227b2d88c67ce84d22995ea1cf6881984..91e9a31b6913e89390ed1d179ea4aa3f6c626f46 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressurevelocityadaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dpressurevelocityadaptive.hh @@ -227,7 +227,7 @@ template void FvMpfaL2dPressureVelocity2pAdaptive::calculateVelocity() { // run through all elements - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dvelocity.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dvelocity.hh index 5537f5ef89885982285de99c9b1c28a2a941df80..b75effed29b3f56cc7755cba223a4e622de8cafa 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dvelocity.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/2dvelocity.hh @@ -182,7 +182,7 @@ public: = *(writer.template allocateManagedBuffer(problem_.gridView().size(0))); // compute update vector - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobal = problem_.variables().index(element); @@ -193,7 +193,7 @@ public: Dune::FieldVector < Scalar, 2 * dim > fluxNw(0); // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int isIndex = intersection.indexInInside(); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dinteractionvolumecontainer.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dinteractionvolumecontainer.hh index 68cd6e2faee83f9efc3748c9bf90cdc3ef7a4c37..d950ade0f25a1760c8561f85fd884051fbececd5 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dinteractionvolumecontainer.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dinteractionvolumecontainer.hh @@ -375,7 +375,7 @@ void FvMpfaL3dInteractionVolumeContainer::storeIntersectionInfo(const E int levelI = element.level(); // run through all intersections - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int indexInInside = intersection.indexInInside(); @@ -1992,7 +1992,7 @@ void FvMpfaL3dInteractionVolumeContainer::storeInteractionVolumeInfo() std::vector < std::vector > elemVertMap(problem_.gridView().size(dim), std::vector(8, -1)); //Add elements to the interaction volumes and store element-vertex map - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) storeSubVolumeElements(element, elemVertMap); for (unsigned int i = 0; i < interactionVolumes_.size(); i++) @@ -2000,12 +2000,12 @@ void FvMpfaL3dInteractionVolumeContainer::storeInteractionVolumeInfo() interactionVolumes_[i].printInteractionVolumeInfo(); // Store information related to DUNE intersections for all interaction volumes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) storeIntersectionInfo(element, elemVertMap); // Complete storage of the interaction volumes using the previously stored information // about the orientation and relationship of the DUNE elements in the interaction volumes (see doc/docextra/3dmpfa) - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dinteractionvolumecontaineradaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dinteractionvolumecontaineradaptive.hh index 19537768bb731149fd4e759a51294483b7611e70..aa342558f6c9373fc8753a192c0904ac5a729e23 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dinteractionvolumecontaineradaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dinteractionvolumecontaineradaptive.hh @@ -515,7 +515,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter auto element1 = interactionVolume.getSubVolumeElement(0); - for (const auto& intersection : Dune::intersections(problem_.gridView(), element1)) + for (const auto& intersection : intersections(problem_.gridView(), element1)) { int idxInInside = intersection.indexInInside(); @@ -548,13 +548,13 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter auto element45 = interactionVolume.getSubVolumeElement(4); auto element23 = interactionVolume.getSubVolumeElement(2); - for (const auto& intersection1 : Dune::intersections(problem_.gridView(), element45)) + for (const auto& intersection1 : intersections(problem_.gridView(), element45)) { if (intersection1.neighbor()) { auto element45Outside = intersection1.outside(); - for (const auto& intersection2 : Dune::intersections(problem_.gridView(), element23)) + for (const auto& intersection2 : intersections(problem_.gridView(), element23)) { if (intersection2.neighbor()) { @@ -772,7 +772,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter auto outside1 = element1; auto outside4 = element4; - for (const auto& intersection1 : Dune::intersections(problem_.gridView(), element1)) + for (const auto& intersection1 : intersections(problem_.gridView(), element1)) { if (intersection1.neighbor()) { @@ -783,7 +783,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter } } } - for (const auto& intersection4 : Dune::intersections(problem_.gridView(), element4)) + for (const auto& intersection4 : intersections(problem_.gridView(), element4)) { if (intersection4.neighbor()) { @@ -866,7 +866,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter faceArea = crossProduct(crossProductVector1, crossProductVector2).two_norm()/2.0; interactionVolume.setFaceArea(faceArea, 11); - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (intersection.indexInInside() == interactionVolume.getIndexOnElement(0, 2)) { @@ -894,7 +894,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter auto element3 = interactionVolume.getSubVolumeElement(2); auto element4 = interactionVolume.getSubVolumeElement(3); - for (const auto& intersection1 : Dune::intersections(problem_.gridView(), element1)) + for (const auto& intersection1 : intersections(problem_.gridView(), element1)) { if (intersection1.neighbor()) { @@ -908,7 +908,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter } } } - for (const auto& intersection2 : Dune::intersections(problem_.gridView(), element2)) + for (const auto& intersection2 : intersections(problem_.gridView(), element2)) { if (intersection2.neighbor()) { @@ -924,7 +924,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter } } } - for (const auto& intersection3 : Dune::intersections(problem_.gridView(), element3)) + for (const auto& intersection3 : intersections(problem_.gridView(), element3)) { if (intersection3.neighbor()) { @@ -939,7 +939,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter } } } - for (const auto& intersection4 : Dune::intersections(problem_.gridView(), element4)) + for (const auto& intersection4 : intersections(problem_.gridView(), element4)) { if (intersection4.neighbor()) { @@ -1023,7 +1023,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter interactionVolume.setFacePosition(element5.geometry().center(), 4); interactionVolume.setFacePosition(element7.geometry().center(), 6); - for (const auto& intersection : Dune::intersections(problem_.gridView(), element5)) + for (const auto& intersection : intersections(problem_.gridView(), element5)) { if (intersection.neighbor()) { @@ -1073,7 +1073,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter interactionVolume.setFacePosition(element5.geometry().center(), 7); interactionVolume.setFacePosition(globalPosFace, 6); - for (const auto& intersection : Dune::intersections(problem_.gridView(), element5)) + for (const auto& intersection : intersections(problem_.gridView(), element5)) { if (intersection.neighbor()) { @@ -1344,7 +1344,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter bool hasFaceOne = false; bool hasFaceTwo = false; - for (const auto& intersection : Dune::intersections(problem_.gridView(), element1)) + for (const auto& intersection : intersections(problem_.gridView(), element1)) { if (intersection.indexInInside() == interactionVolume.getIndexOnElement(0, 1)) { @@ -1481,7 +1481,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeHangingNodeInter auto element3 = interactionVolume.getSubVolumeElement(2); - for (const auto& intersection : Dune::intersections(problem_.gridView(), element3)) + for (const auto& intersection : intersections(problem_.gridView(), element3)) { if (intersection.indexInInside() == interactionVolume.getIndexOnElement(2, 2)) { @@ -1592,7 +1592,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeInteractionVolum std::vector < std::vector > elemVertMap(problem_.gridView().size(dim), std::vector(8, -1)); //Add elements to the interaction volumes and store element-vertex map - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) asImp_().storeSubVolumeElements(element, elemVertMap); for (unsigned int i = 0; i < asImp_().interactionVolumes_.size(); i++) @@ -1600,7 +1600,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeInteractionVolum asImp_().interactionVolumes_[i].printInteractionVolumeInfo(); // Store information related to DUNE intersections for all interaction volumes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) asImp_().storeIntersectionInfo(element, elemVertMap); faceVertices_.clear(); @@ -1608,7 +1608,7 @@ void FvMpfaL3dInteractionVolumeContainerAdaptive::storeInteractionVolum // Complete storage of the interaction volumes using the previously stored information // about the orientation and relationship of the DUNE elements in the interaction volumes (see doc/docextra/3dmpfa) - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressure.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressure.hh index c3b08bd57ff47a73163f03cebb45cf28cabc63d0..d96ae57c0f3d048a4f84f1ee7e814c7377dcf8e0 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressure.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressure.hh @@ -206,7 +206,7 @@ public: void storePressureSolution() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { storePressureSolution(element); } @@ -401,7 +401,7 @@ public: ScalarSolutionType *potentialSecond = writer.allocateManagedBuffer(size); ScalarSolutionType *pc = writer.allocateManagedBuffer(size); - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int idx = problem_.variables().index(element); CellData& cellData = problem_.variables().cellData(idx); @@ -549,7 +549,7 @@ template void FvMpfaL3dPressure2p::initializeMatrixRowSize() { // determine matrix row sizes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -586,7 +586,7 @@ template void FvMpfaL3dPressure2p::initializeMatrixIndices() { // determine position of matrix entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -624,7 +624,7 @@ void FvMpfaL3dPressure2p::assemble() this->f_ = 0; // run through all vertices - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); @@ -2474,7 +2474,7 @@ template void FvMpfaL3dPressure2p::updateMaterialLaws() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressureadaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressureadaptive.hh index 947162e748f984228fb0f9587ab46f28e1f79576..37d58fa5bfe846f97bf9dae28643ba718f79bec7 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressureadaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressureadaptive.hh @@ -282,7 +282,7 @@ template void FvMpfaL3dPressure2pAdaptive::initializeMatrixRowSize() { // determine matrix row sizes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int globalIdxI = problem_.variables().index(element); @@ -366,7 +366,7 @@ template void FvMpfaL3dPressure2pAdaptive::initializeMatrixIndices() { // determine position of matrix entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int globalIdxI = problem_.variables().index(element); @@ -417,7 +417,7 @@ void FvMpfaL3dPressure2pAdaptive::assemble() this->f_ = 0; // run through all vertices - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { #if HAVE_MPI if (vertex.partitionType() != Dune::InteriorEntity && vertex.partitionType() != Dune::BorderEntity) diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressurevelocity.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressurevelocity.hh index 5f33ebc16687c6eaa5a984515d7cb870cfb28904..315b693d8d37310229a8453296131647b613cbd7 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressurevelocity.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressurevelocity.hh @@ -212,7 +212,7 @@ template void FvMpfaL3dPressureVelocity2p::calculateVelocity() { // run through all vertices - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressurevelocityadaptive.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressurevelocityadaptive.hh index 21fdc039f84e47c8f23e8fe5b6a770d37616b31b..09017e81657254af54e8415cbb76083fe55acb8f 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressurevelocityadaptive.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dpressurevelocityadaptive.hh @@ -213,7 +213,7 @@ template void FvMpfaL3dPressureVelocity2pAdaptive::calculateVelocity() { // run through all vertices - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dvelocity.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dvelocity.hh index 4a2ef9b72378c307c19c81a234573a92c1840d5c..907f252f47d5d2d31036dee480f0ed30f2793d47 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dvelocity.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/lmethod/3dvelocity.hh @@ -197,7 +197,7 @@ public: dim>(problem_.gridView().size(0))); // compute update vector - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobal = problem_.variables().index(element); @@ -208,7 +208,7 @@ public: Dune::FieldVector < Scalar, 2 * dim > fluxNw(0); // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int isIndex = intersection.indexInInside(); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dpressure.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dpressure.hh index a1cd9a14ba2f443f115ac041467bfc03fa0a8204..8077e3339644aa152d5438e53af6c9e17d39d814 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dpressure.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dpressure.hh @@ -251,7 +251,7 @@ public: void storePressureSolution() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { storePressureSolution(element); } @@ -344,7 +344,7 @@ public: ScalarSolutionType *potentialSecond = writer.allocateManagedBuffer(size); ScalarSolutionType *pc = writer.allocateManagedBuffer(size); - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int idx = problem_.variables().index(element); CellData& cellData = problem_.variables().cellData(idx); @@ -555,7 +555,7 @@ template void FvMpfaO2dPressure2p::initializeMatrix() { // determine matrix row sizes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -577,9 +577,9 @@ void FvMpfaO2dPressure2p::initializeMatrix() if (intersection.neighbor() && nextIntersection.neighbor()) { for (const auto& innerIntersection - : Dune::intersections(problem_.gridView(), intersection.outside())) + : intersections(problem_.gridView(), intersection.outside())) for (const auto& innerNextIntersection - : Dune::intersections(problem_.gridView(), nextIntersection.outside())) + : intersections(problem_.gridView(), nextIntersection.outside())) { if (innerIntersection.neighbor() && innerNextIntersection.neighbor()) { @@ -602,7 +602,7 @@ void FvMpfaO2dPressure2p::initializeMatrix() this->A_.endrowsizes(); // determine position of matrix entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -630,9 +630,9 @@ void FvMpfaO2dPressure2p::initializeMatrix() if (intersection.neighbor() && nextIntersection.neighbor()) { for (const auto& innerIntersection - : Dune::intersections(problem_.gridView(), intersection.outside())) + : intersections(problem_.gridView(), intersection.outside())) for (const auto& innerNextIntersection - : Dune::intersections(problem_.gridView(), nextIntersection.outside())) + : intersections(problem_.gridView(), nextIntersection.outside())) { if (innerIntersection.neighbor() && innerNextIntersection.neighbor()) { @@ -695,7 +695,7 @@ void FvMpfaO2dPressure2p::storeInteractionVolumeInfo() BoundaryTypes bcType; // run through all elements - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get common geometry information for the following computation @@ -860,12 +860,12 @@ void FvMpfaO2dPressure2p::storeInteractionVolumeInfo() GlobalPosition globalPosFace34(0); for (const auto& intersection2 - : Dune::intersections(problem_.gridView(), element2)) + : intersections(problem_.gridView(), element2)) { bool finished = false; for (const auto& intersection4 - : Dune::intersections(problem_.gridView(), element4)) + : intersections(problem_.gridView(), element4)) { if (intersection2.neighbor() && intersection4.neighbor()) { @@ -1000,7 +1000,7 @@ void FvMpfaO2dPressure2p::storeInteractionVolumeInfo() bool finished = false; for (const auto& intersection2 - : Dune::intersections(problem_.gridView(), element2)) + : intersections(problem_.gridView(), element2)) { if (intersection2.boundary()) { @@ -1146,7 +1146,7 @@ void FvMpfaO2dPressure2p::storeInteractionVolumeInfo() // get the information of the face 'isIt34' between cell3 and cell4 (locally numbered) for (const auto& intersection4 - : Dune::intersections(problem_.gridView(), element4)) + : intersections(problem_.gridView(), element4)) { if (intersection4.boundary()) { @@ -1246,7 +1246,7 @@ void FvMpfaO2dPressure2p::assemble() this->f_ = 0; // run through all vertices - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); @@ -1894,7 +1894,7 @@ void FvMpfaO2dPressure2p::assemble() if (problem_.gridView().comm().size() > 1) { // set ghost and overlap element entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { if (element.partitionType() == Dune::InteriorEntity) continue; @@ -1920,7 +1920,7 @@ template void FvMpfaO2dPressure2p::updateMaterialLaws() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dpressurevelocity.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dpressurevelocity.hh index 4f9165a10a2742ca413172f6c6676638a5f8e9dc..06b6061a286d8764d98730539782b09ef374e3c5 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dpressurevelocity.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dpressurevelocity.hh @@ -219,7 +219,7 @@ template void FvMpfaO2dPressureVelocity2p::calculateVelocity() { // run through all elements - for (const auto& vertex : Dune::vertices(problem_.gridView())) + for (const auto& vertex : vertices(problem_.gridView())) { int vIdxGlobal = problem_.variables().index(vertex); diff --git a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dvelocity.hh b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dvelocity.hh index d464efca51135f235aea55ff20569873436a3f2c..30f054984cf20756b016a9f7710911137211a343 100644 --- a/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dvelocity.hh +++ b/dumux/porousmediumflow/2p/sequential/diffusion/mpfa/omethod/2dvelocity.hh @@ -180,7 +180,7 @@ public: dim>(problem_.gridView().size(0))); // compute update vector - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobal = problem_.variables().index(element); @@ -191,7 +191,7 @@ public: Dune::FieldVector < Scalar, 2 * dim > fluxNw(0); // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int isIndex = intersection.indexInInside(); diff --git a/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicator.hh b/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicator.hh index 76337cfe7e848c6be1f667e4e7bd7a649a73fbb0..c37bb95f9b767341925575d4130f34ed42c83ce1 100644 --- a/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicator.hh +++ b/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicator.hh @@ -79,7 +79,7 @@ public: // 1) calculate Indicator -> min, maxvalues // loop over all leaf-elements - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // calculate minimum and maximum saturation // index of the current leaf-elements @@ -100,7 +100,7 @@ public: globalMax = std::max(satI, globalMax); // calculate refinement indicator in all cells - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { // Only consider internal intersections if (intersection.neighbor()) diff --git a/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicatorlocal.hh b/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicatorlocal.hh index 53bcc441453ee71040283d75a546560c1a080544..792d9f623850c4b35890d4ef19ac98dd2fff323d 100644 --- a/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicatorlocal.hh +++ b/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicatorlocal.hh @@ -82,7 +82,7 @@ public: // 1) calculate Indicator -> min, maxvalues // loop over all leaf-elements - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // calculate minimum and maximum saturation // index of the current leaf-elements @@ -122,7 +122,7 @@ public: globalMax = std::max(satI, globalMax); // calculate refinement indicator in all cells - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (indicatorVector_[globalIdxI] == 10) { diff --git a/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicatorlocalflux.hh b/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicatorlocalflux.hh index c15ac2d6ad6a0c6e96489c836f3013b2d32f5f27..0adca7a758ee16e6aa545d506135998ceb91131f 100644 --- a/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicatorlocalflux.hh +++ b/dumux/porousmediumflow/2p/sequential/impes/gridadaptionindicatorlocalflux.hh @@ -147,7 +147,7 @@ public: // 1) calculate Indicator -> min, maxvalues // Schleife über alle Leaf-Elemente - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // Bestimme maximale und minimale Sättigung // Index des aktuellen Leaf-Elements @@ -216,7 +216,7 @@ public: std::vector flux(numberOfFaces,0); // Calculate refinement indicator on all cells - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (isSpecialCell) { diff --git a/dumux/porousmediumflow/2p/sequential/transport/cellcentered/saturation.hh b/dumux/porousmediumflow/2p/sequential/transport/cellcentered/saturation.hh index 851f73f4a31e174059e0b66058597de6712c1598..465eaccdbb09b8198f9613c1deba55a9f423535c 100644 --- a/dumux/porousmediumflow/2p/sequential/transport/cellcentered/saturation.hh +++ b/dumux/porousmediumflow/2p/sequential/transport/cellcentered/saturation.hh @@ -1130,7 +1130,7 @@ void FVSaturation2P::initialize() } // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { PrimaryVariables initSol(0.0); problem_.initial(initSol, element); @@ -1173,7 +1173,7 @@ template void FVSaturation2P::updateMaterialLaws() { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int eIdxGlobal = problem_.variables().index(element); diff --git a/dumux/porousmediumflow/2p2c/implicit/model.hh b/dumux/porousmediumflow/2p2c/implicit/model.hh index d298e467b3f968e3026f55fff7b10f8603aabdea..34aa67a6ec5c2a4eae50c6ad9e6944275a8e0cf3 100644 --- a/dumux/porousmediumflow/2p2c/implicit/model.hh +++ b/dumux/porousmediumflow/2p2c/implicit/model.hh @@ -154,7 +154,7 @@ public: setSwitched_(false); // check, if velocity output can be used (works only for cubes so far) - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if (!isBox) // i.e. cell-centered discretization { @@ -174,7 +174,7 @@ public: if (isBox) // i.e. vertex-centered discretization { - for (const auto& vertex : Dune::vertices(this->gridView_())) + for (const auto& vertex : vertices(this->gridView_())) { int vIdxGlobal = this->dofMapper().index(vertex); const GlobalPosition &globalPos = vertex.geometry().corner(0); @@ -201,7 +201,7 @@ public: { storage = 0; - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { @@ -321,7 +321,7 @@ public: unsigned numElements = this->gridView_().size(0); ScalarField *rank = writer.allocateManagedBuffer(numElements); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { @@ -481,7 +481,7 @@ public: FVElementGeometry fvGeometry; static VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/dumux/porousmediumflow/2p2c/sequential/fv2dpressureadaptive.hh b/dumux/porousmediumflow/2p2c/sequential/fv2dpressureadaptive.hh index ab0dc6fdcfc23603c4f30cddf707add6ca1d90b9..8c85d225f23f0b656a63e921c38fb0d162851e25 100644 --- a/dumux/porousmediumflow/2p2c/sequential/fv2dpressureadaptive.hh +++ b/dumux/porousmediumflow/2p2c/sequential/fv2dpressureadaptive.hh @@ -226,7 +226,7 @@ void FV2dPressure2P2CAdaptive::initializeMatrix() this->f_.resize(gridSize_); // determine matrix row sizes - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // cell index int globalIdxI = problem().variables().index(element); @@ -273,7 +273,7 @@ void FV2dPressure2P2CAdaptive::initializeMatrix() { bool increaseRowSize = true; //check if additional cell is ordinary neighbor of eIt - for (const auto& intersection2 : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection2 : intersections(problem_.gridView(), element)) { if(!intersection2.neighbor()) continue; @@ -301,7 +301,7 @@ void FV2dPressure2P2CAdaptive::initializeMatrix() this->A_.endrowsizes(); // determine position of matrix entries - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // cell index int globalIdxI = problem().variables().index(element); @@ -372,7 +372,7 @@ void FV2dPressure2P2CAdaptive::assemble(bool first) this->A_ = 0; this->f_ = 0; - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get the global index of the cell int globalIdxI = problem().variables().index(element); diff --git a/dumux/porousmediumflow/2p2c/sequential/fv2dtransportadaptive.hh b/dumux/porousmediumflow/2p2c/sequential/fv2dtransportadaptive.hh index a27e7bcdbae22c9df35c37dc027999d24d3f8aa5..f7a6b1cc7f182cf441099ce76bb0eb7475835dff 100644 --- a/dumux/porousmediumflow/2p2c/sequential/fv2dtransportadaptive.hh +++ b/dumux/porousmediumflow/2p2c/sequential/fv2dtransportadaptive.hh @@ -192,7 +192,7 @@ void FV2dTransport2P2CAdaptive::update(const Scalar t, Scalar& dt, Tran Dune::FieldVector entries(0.), timestepFlux(0.); // compute update vector - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get cell infos int globalIdxI = problem().variables().index(element); diff --git a/dumux/porousmediumflow/2p2c/sequential/fv3dpressureadaptive.hh b/dumux/porousmediumflow/2p2c/sequential/fv3dpressureadaptive.hh index 72009677ef36bb1f49860d212480a9335eb605fd..17b92e12093e137c80a5c6a3b8a734f115e011e0 100644 --- a/dumux/porousmediumflow/2p2c/sequential/fv3dpressureadaptive.hh +++ b/dumux/porousmediumflow/2p2c/sequential/fv3dpressureadaptive.hh @@ -218,7 +218,7 @@ public: int gridSize = problem().gridView().size(0); this->pressure().resize(gridSize); - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get the global index of the cell int eIdxGlobalI = problem().variables().index(element); @@ -332,7 +332,7 @@ template void FV3dPressure2P2CAdaptive::initializeMatrixRowSize() { // determine matrix row sizes - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // cell index int eIdxGlobalI = problem().variables().index(element); @@ -349,7 +349,7 @@ void FV3dPressure2P2CAdaptive::initializeMatrixRowSize() int numberOfIntersections = 0; // run through all intersections with neighbors - for (const auto& intersection : Dune::intersections(problem().gridView(), element)) + for (const auto& intersection : intersections(problem().gridView(), element)) { cellDataI.perimeter() += intersection.geometry().volume(); numberOfIntersections++; @@ -386,7 +386,7 @@ void FV3dPressure2P2CAdaptive::initializeMatrixRowSize() std::multimap::iterator rangeIt; // second loop for further sub-faces - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // cell index int eIdxGlobalI = problem().variables().index(element); @@ -443,7 +443,7 @@ void FV3dPressure2P2CAdaptive::initializeMatrixRowSize() bool additional2isNeighbor(false), additional3isNeighbor(false); // run through all intersections with neighbors if eIt for (const auto& checkIntersection - : Dune::intersections(problem().gridView(), element)) + : intersections(problem().gridView(), element)) { if (checkIntersection.neighbor()) { @@ -503,7 +503,7 @@ void FV3dPressure2P2CAdaptive::initializeMatrixRowSize() additional2isNeighbor = additional3isNeighbor = false; // run through all intersections with neighbors of J for (const auto& checkIntersection - : Dune::intersections(problem().gridView(), intersection.outside())) + : intersections(problem().gridView(), intersection.outside())) { if (checkIntersection.neighbor()) { @@ -575,7 +575,7 @@ template void FV3dPressure2P2CAdaptive::initializeMatrixIndices() { // determine position of matrix entries - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // cell index int eIdxGlobalI = problem().variables().index(element); @@ -650,7 +650,7 @@ void FV3dPressure2P2CAdaptive::assemble(bool first) this->A_ = 0; this->f_ = 0; - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get the global index of the cell int eIdxGlobalI = problem().variables().index(element); @@ -1292,7 +1292,7 @@ void FV3dPressure2P2CAdaptive::updateMaterialLaws(bool fromPostTimestep { Scalar maxError = 0.; // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { int eIdxGlobal = problem().variables().index(element); CellData& cellData = problem().variables().cellData(eIdxGlobal); diff --git a/dumux/porousmediumflow/2p2c/sequential/fv3dtransportadaptive.hh b/dumux/porousmediumflow/2p2c/sequential/fv3dtransportadaptive.hh index 2b6c530e21396e1651b9b531bf815f80b65f5406..5a231b0682c9124e998e22f23122f1e27db44c33 100644 --- a/dumux/porousmediumflow/2p2c/sequential/fv3dtransportadaptive.hh +++ b/dumux/porousmediumflow/2p2c/sequential/fv3dtransportadaptive.hh @@ -201,7 +201,7 @@ void FV3dTransport2P2CAdaptive::update(const Scalar t, Scalar& dt, Dune::FieldVector entries(0.), timestepFlux(0.); // compute update vector - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get cell infos int globalIdxI = problem().variables().index(element); diff --git a/dumux/porousmediumflow/2p2c/sequential/fvpressurecompositional.hh b/dumux/porousmediumflow/2p2c/sequential/fvpressurecompositional.hh index 092b1e18a6c551348c661c915440edf1b1fefc82..d9dcc42b7f1e6b3efe4d226e0749aaeb96d16be1 100644 --- a/dumux/porousmediumflow/2p2c/sequential/fvpressurecompositional.hh +++ b/dumux/porousmediumflow/2p2c/sequential/fvpressurecompositional.hh @@ -316,7 +316,7 @@ public: Dune::BlockVector > poro_(0.), perm_(0.); poro_.resize(size_); perm_.resize(size_); // iterate over all elements of domain - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get index int eIdxGlobal = problem_.variables().index(element); @@ -335,7 +335,7 @@ public: Dune::BlockVector > permY_(0.), permZ_(0.); permY_.resize(size_); permZ_.resize(size_); // iterate over all elements of domain - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get index int eIdxGlobal = problem_.variables().index(element); @@ -525,7 +525,7 @@ template void FVPressureCompositional::initialMaterialLaws(bool compositional) { // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get global coordinate of cell center GlobalPosition globalPos = element.geometry().center(); @@ -678,7 +678,7 @@ void FVPressureCompositional::initialMaterialLaws(bool compositional) if(!compositional) { // run through all intersections with neighbors - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { cellData.perimeter() += intersection.geometry().volume(); @@ -707,7 +707,7 @@ void FVPressureCompositional::updateMaterialLaws(bool postTimeStep) { Scalar maxError = 0.; // iterate through leaf grid an evaluate c0 at cell center - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { int eIdxGlobal = problem().variables().index(element); diff --git a/dumux/porousmediumflow/2p2c/sequential/fvpressuremultiphysics.hh b/dumux/porousmediumflow/2p2c/sequential/fvpressuremultiphysics.hh index a0a2123089d394f0e6d8349618a4cd42be1b5595..d3ae37c791518ba91f93e1fadfd4bc2fce73ce52 100644 --- a/dumux/porousmediumflow/2p2c/sequential/fvpressuremultiphysics.hh +++ b/dumux/porousmediumflow/2p2c/sequential/fvpressuremultiphysics.hh @@ -262,7 +262,7 @@ void FVPressure2P2CMultiPhysics::assemble(bool first) this->A_ = 0; this->f_ = 0; - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get the global index of the cell int eIdxGlobalI = problem().variables().index(element); @@ -285,7 +285,7 @@ void FVPressure2P2CMultiPhysics::assemble(bool first) /***** flux term ***********/ // iterate over all faces of the cell - for (const auto& intersection : Dune::intersections(problem().gridView(), element)) + for (const auto& intersection : intersections(problem().gridView(), element)) { /************* handle interior face *****************/ if (intersection.neighbor()) @@ -781,7 +781,7 @@ void FVPressure2P2CMultiPhysics::updateMaterialLaws(bool postTimeStep) nextSubdomain = -1; // reduce complexity after first TS // Loop A) through leaf grid - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get global coordinate of cell center int eIdxGlobal = problem().variables().index(element); @@ -805,7 +805,7 @@ void FVPressure2P2CMultiPhysics::updateMaterialLaws(bool postTimeStep) nextSubdomain[eIdxGlobal] = 2; // mark neighbors - for (const auto& intersection : Dune::intersections(problem().gridView(), element)) + for (const auto& intersection : intersections(problem().gridView(), element)) { if (intersection.neighbor()) { @@ -842,7 +842,7 @@ void FVPressure2P2CMultiPhysics::updateMaterialLaws(bool postTimeStep) // Loop B) thorugh leaf grid // investigate cells that were "simple" in current TS - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { int eIdxGlobal = problem().variables().index(element); CellData& cellData = problem().variables().cellData(eIdxGlobal); diff --git a/dumux/porousmediumflow/2p2c/sequential/fvtransport.hh b/dumux/porousmediumflow/2p2c/sequential/fvtransport.hh index 9336a21887be15bf86d01d68c29f7b2c4687ff81..d417607e8dd7a81d74d4e4b827f0af19d6843a12 100644 --- a/dumux/porousmediumflow/2p2c/sequential/fvtransport.hh +++ b/dumux/porousmediumflow/2p2c/sequential/fvtransport.hh @@ -385,7 +385,7 @@ void FVTransport2P2C::update(const Scalar t, Scalar& dt, ComponentVector entries(0.); EntryType timestepFlux(0.); // compute update vector - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get cell infos int eIdxGlobalI = problem().variables().index(element); @@ -396,7 +396,7 @@ void FVTransport2P2C::update(const Scalar t, Scalar& dt, double sumfactorout = 0; // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem().gridView(), element)) + for (const auto& intersection : intersections(problem().gridView(), element)) { int indexInInside = intersection.indexInInside(); @@ -1183,7 +1183,7 @@ void FVTransport2P2C::updatedTargetDt_(Scalar &dt) dt = std::numeric_limits::max(); // update target time-step-sizes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { #if HAVE_MPI if (element.partitionType() != Dune::InteriorEntity) @@ -1202,7 +1202,7 @@ void FVTransport2P2C::updatedTargetDt_(Scalar &dt) FaceDt faceDt; // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int indexInInside = intersection.indexInInside(); @@ -1264,7 +1264,7 @@ void FVTransport2P2C::updatedTargetDt_(Scalar &dt) localDataI.faceTargetDt[it->first] += subCFLFactor_ * it->second; } - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (intersection.neighbor()) { diff --git a/dumux/porousmediumflow/2p2c/sequential/fvtransportmultiphysics.hh b/dumux/porousmediumflow/2p2c/sequential/fvtransportmultiphysics.hh index ac18ff0109ae8800351938bbb7a6ab83d23b7e2e..5a4c15dab60124d0a5626e3cb26e0e77253ccaae 100644 --- a/dumux/porousmediumflow/2p2c/sequential/fvtransportmultiphysics.hh +++ b/dumux/porousmediumflow/2p2c/sequential/fvtransportmultiphysics.hh @@ -142,7 +142,7 @@ void FVTransport2P2CMultiPhysics::update(const Scalar t, Scalar& dt, Tr PhaseVector entries(0.), timestepFlux(0.); // compute update vector - for (const auto& element : Dune::elements(problem().gridView())) + for (const auto& element : elements(problem().gridView())) { // get cell infos int globalIdxI = problem().variables().index(element); @@ -155,7 +155,7 @@ void FVTransport2P2CMultiPhysics::update(const Scalar t, Scalar& dt, Tr double sumfactorout = 0; // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem().gridView(), element)) + for (const auto& intersection : intersections(problem().gridView(), element)) { int indexInInside = intersection.indexInInside(); diff --git a/dumux/porousmediumflow/2pminc/implicit/model.hh b/dumux/porousmediumflow/2pminc/implicit/model.hh index 301b4497f4cec8a89cdd3da500eefd7056c476ad..0c0c1c9d5a39794e9be9967b3d66b9629eaa65ff 100644 --- a/dumux/porousmediumflow/2pminc/implicit/model.hh +++ b/dumux/porousmediumflow/2pminc/implicit/model.hh @@ -154,7 +154,7 @@ public: unsigned numElements = this->gridView_().size(0); ScalarField *rank = writer.allocateManagedBuffer(numElements); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int eIdx = this->elementMapper().index(element); (*rank)[eIdx] = this->gridView_().comm().rank(); diff --git a/dumux/porousmediumflow/2pnc/implicit/model.hh b/dumux/porousmediumflow/2pnc/implicit/model.hh index 7daf35faacf8807b46b231c46718f76d3602d7dd..5adcc75331c8e7011c0ff7446ae1d74124c465f1 100644 --- a/dumux/porousmediumflow/2pnc/implicit/model.hh +++ b/dumux/porousmediumflow/2pnc/implicit/model.hh @@ -166,7 +166,7 @@ public: setSwitched_(false); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if (!isBox) // i.e. cell-centered discretization { @@ -186,7 +186,7 @@ public: if (isBox) // i.e. vertex-centered discretization { - for (const auto& vertex : Dune::vertices(this->gridView_())) + for (const auto& vertex : vertices(this->gridView_())) { int dofIdxGlobal = this->dofMapper().index(vertex); const GlobalPosition &globalPos = vertex.geometry().corner(0); @@ -213,7 +213,7 @@ public: { storage = 0; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { @@ -343,7 +343,7 @@ public: VolumeVariables volVars; ElementVolumeVariables elemVolVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int eIdxGlobal = this->problem_().elementMapper().index(element); (*rank)[eIdxGlobal] = this->gridView_().comm().rank(); @@ -510,7 +510,7 @@ public: FVElementGeometry fvGeometry; static VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/dumux/porousmediumflow/2pncmin/implicit/model.hh b/dumux/porousmediumflow/2pncmin/implicit/model.hh index 9649493ab963002871a2bcdc1f6187a9290def6a..9eb8121599fb8ff2b501ecbba680f0ddbc9cb0e4 100644 --- a/dumux/porousmediumflow/2pncmin/implicit/model.hh +++ b/dumux/porousmediumflow/2pncmin/implicit/model.hh @@ -237,7 +237,7 @@ public: VolumeVariables volVars; ElementVolumeVariables elemVolVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int idx = this->problem_().elementMapper().index(element); (*rank)[idx] = this->gridView_().comm().rank(); @@ -380,7 +380,7 @@ public: FVElementGeometry fvGeometry; static VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); for (int i = 0; i < fvGeometry.numScv; ++i) diff --git a/dumux/porousmediumflow/3p/implicit/model.hh b/dumux/porousmediumflow/3p/implicit/model.hh index ac6cd1170911c4df53313f9f5c74a0cb2ddf3cc0..29975622d2715e98cfa62d6d63c926a7783a7117 100644 --- a/dumux/porousmediumflow/3p/implicit/model.hh +++ b/dumux/porousmediumflow/3p/implicit/model.hh @@ -135,7 +135,7 @@ public: unsigned numElements = this->gridView_().size(0); ScalarField *rank = writer.allocateManagedBuffer (numElements); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/porousmediumflow/3p3c/implicit/model.hh b/dumux/porousmediumflow/3p3c/implicit/model.hh index 6801ed9d4d3ca1703d9cb3a22b0500362134be42..ba335420e8b63a157296482beb1bf140066d5e0d 100644 --- a/dumux/porousmediumflow/3p3c/implicit/model.hh +++ b/dumux/porousmediumflow/3p3c/implicit/model.hh @@ -155,7 +155,7 @@ public: if (isBox) { - for (const auto& vertex : Dune::vertices(this->gridView_())) + for (const auto& vertex : vertices(this->gridView_())) { int vIdxGlobal = this->dofMapper().index(vertex); @@ -173,7 +173,7 @@ public: } else { - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { int eIdxGlobal = this->dofMapper().index(element); const GlobalPosition &globalPos = element.geometry().center(); @@ -201,7 +201,7 @@ public: { storage = 0; - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { this->localResidual().evalPhaseStorage(element, phaseIdx); @@ -321,7 +321,7 @@ public: unsigned numElements = this->gridView_().size(0); ScalarField *rank = writer.allocateManagedBuffer (numElements); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { @@ -469,7 +469,7 @@ public: FVElementGeometry fvGeometry; static VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/dumux/porousmediumflow/co2/implicit/model.hh b/dumux/porousmediumflow/co2/implicit/model.hh index f4e5867e043146eedd9a1bb05c8b44283f3849ee..7994eb2b45492768300abc98dbdaa74daee37546 100644 --- a/dumux/porousmediumflow/co2/implicit/model.hh +++ b/dumux/porousmediumflow/co2/implicit/model.hh @@ -107,7 +107,7 @@ public: FVElementGeometry fvGeometry; static VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { fvGeometry.update(this->gridView_(), element); diff --git a/dumux/porousmediumflow/implicit/velocityoutput.hh b/dumux/porousmediumflow/implicit/velocityoutput.hh index 3bbc8116a25906f71143eeb33346413ae77851ec..7e36ed451bb7ede38929883ffa803de16ed970c4 100644 --- a/dumux/porousmediumflow/implicit/velocityoutput.hh +++ b/dumux/porousmediumflow/implicit/velocityoutput.hh @@ -85,7 +85,7 @@ public: { cellNum_.assign(problem_.gridView().size(dofCodim), 0); - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { FVElementGeometry fvGeometry; fvGeometry.update(problem_.gridView(), element); @@ -213,7 +213,7 @@ public: std::vector scvfFluxes(element.subEntities(1), 0); int fIdxInner = 0; - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int fIdx = intersection.indexInInside(); @@ -248,7 +248,7 @@ public: // Neumann conditions. if (element.hasBoundaryIntersections()) { - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (intersection.boundary()) { diff --git a/dumux/porousmediumflow/mpnc/implicit/model.hh b/dumux/porousmediumflow/mpnc/implicit/model.hh index e60daf5b2a6acd05671e88df397594c14e88684c..82575820fc890801b73b68bfbccdfaf19769d130 100644 --- a/dumux/porousmediumflow/mpnc/implicit/model.hh +++ b/dumux/porousmediumflow/mpnc/implicit/model.hh @@ -179,7 +179,7 @@ public: { phaseStorage = 0; - for (const auto& element : Dune::elements(this->gridView_())) { + for (const auto& element : elements(this->gridView_())) { this->localResidual().addPhaseStorage(phaseStorage, element, phaseIdx); } diff --git a/dumux/porousmediumflow/mpnc/implicit/modelkinetic.hh b/dumux/porousmediumflow/mpnc/implicit/modelkinetic.hh index 135180101795f78c9be90253695ecb95129f0a5d..79aad87dafc69c3cc7cdb3433a5afbe13808e720 100644 --- a/dumux/porousmediumflow/mpnc/implicit/modelkinetic.hh +++ b/dumux/porousmediumflow/mpnc/implicit/modelkinetic.hh @@ -132,7 +132,7 @@ public: } // loop all elements - for (const auto& element : Dune::elements(this->gridView_())){ + for (const auto& element : elements(this->gridView_())){ //obtaining the elementVolumeVariables needed for the Fluxvariables FVElementGeometry fvGeometry; ElementVolumeVariables elemVolVars; @@ -193,7 +193,7 @@ public: // void checkPlausibility() const // { // // Looping over all elements of the domain -// for (const auto& element : Dune::elements(this->gridView_())) +// for (const auto& element : elements(this->gridView_())) // { // ElementVolumeVariables elemVolVars; // FVElementGeometry fvGeometry; diff --git a/dumux/porousmediumflow/mpnc/implicit/vtkwriter.hh b/dumux/porousmediumflow/mpnc/implicit/vtkwriter.hh index d8d43a0b71cd1c569cd19d6fd69702aba57737ae..9fd84683c1b96710bb7539ace121fb153f5760ad 100644 --- a/dumux/porousmediumflow/mpnc/implicit/vtkwriter.hh +++ b/dumux/porousmediumflow/mpnc/implicit/vtkwriter.hh @@ -75,7 +75,7 @@ public: ElementVolumeVariables elemVolVars; ElementBoundaryTypes elemBcTypes; - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/porousmediumflow/nonisothermal/implicit/model.hh b/dumux/porousmediumflow/nonisothermal/implicit/model.hh index 318cbb4805b3cd40e1b6a319bc62a0a6b4edb5e5..1372b4eba0c8b67a71cbd9a08adf4d80c1846b33 100644 --- a/dumux/porousmediumflow/nonisothermal/implicit/model.hh +++ b/dumux/porousmediumflow/nonisothermal/implicit/model.hh @@ -95,7 +95,7 @@ public: typedef Dune::BlockVector > ScalarField; ScalarField &temperature = *writer.allocateManagedBuffer(numDofs); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/porousmediumflow/richards/implicit/model.hh b/dumux/porousmediumflow/richards/implicit/model.hh index 06ac8baf9e4f03dfeed5048039b76b6612cb6d32..92a7cc68269f007b268e3f25ddd9c65fa69cf4a1 100644 --- a/dumux/porousmediumflow/richards/implicit/model.hh +++ b/dumux/porousmediumflow/richards/implicit/model.hh @@ -174,7 +174,7 @@ public: unsigned numElements = this->gridView_().size(0); ScalarField *rank = writer.allocateManagedBuffer (numElements); - for (const auto& element : Dune::elements(this->gridView_())) + for (const auto& element : elements(this->gridView_())) { if(element.partitionType() == Dune::InteriorEntity) { diff --git a/dumux/porousmediumflow/richards/implicit/newtoncontroller.hh b/dumux/porousmediumflow/richards/implicit/newtoncontroller.hh index 6195d8a3f53f56f24cf3944160c456167c698a39..35e7c788412678c3640fe60492c87fa134abfcd3 100644 --- a/dumux/porousmediumflow/richards/implicit/newtoncontroller.hh +++ b/dumux/porousmediumflow/richards/implicit/newtoncontroller.hh @@ -91,7 +91,7 @@ public: // clamp saturation change to at most 20% per iteration FVElementGeometry fvGeometry; const GridView &gridView = this->problem_().gridView(); - for (const auto& element : Dune::elements(gridView)) { + for (const auto& element : elements(gridView)) { fvGeometry.update(gridView, element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) { diff --git a/dumux/porousmediumflow/sequential/cellcentered/pressure.hh b/dumux/porousmediumflow/sequential/cellcentered/pressure.hh index c8390eeb5da3969015ca3417c6dc958df0ada00f..afdec6a7887fa13e4836ee19e9f39403c89962f7 100644 --- a/dumux/porousmediumflow/sequential/cellcentered/pressure.hh +++ b/dumux/porousmediumflow/sequential/cellcentered/pressure.hh @@ -126,7 +126,7 @@ protected: //result in better convergence of the linear solver! void initializePressure() { - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { PrimaryVariables initValues; problem_.initial(initValues, element); @@ -340,7 +340,7 @@ template void FVPressure::initializeMatrixRowSize() { // determine matrix row sizes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -349,7 +349,7 @@ void FVPressure::initializeMatrixRowSize() int rowSize = 1; // run through all intersections with neighbors - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (intersection.neighbor()) rowSize++; @@ -363,7 +363,7 @@ template void FVPressure::initializeMatrixIndices() { // determine position of matrix entries - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell index int eIdxGlobalI = problem_.variables().index(element); @@ -372,7 +372,7 @@ void FVPressure::initializeMatrixIndices() A_.addindex(eIdxGlobalI, eIdxGlobalI); // run through all intersections with neighbors - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) if (intersection.neighbor()) { // access neighbor @@ -402,7 +402,7 @@ void FVPressure::assemble(bool first) A_ = 0; f_ = 0; - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get the global index of the cell int eIdxGlobalI = problem_.variables().index(element); @@ -421,7 +421,7 @@ void FVPressure::assemble(bool first) /***** flux term ***********/ // iterate over all faces of the cell - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { /************* handle interior face *****************/ if (intersection.neighbor()) diff --git a/dumux/porousmediumflow/sequential/cellcentered/transport.hh b/dumux/porousmediumflow/sequential/cellcentered/transport.hh index a2a04311d593154404bd17e5723481af395dc130..054f0f1c9f2f329230eaa703a9fe3f2075c8d893 100644 --- a/dumux/porousmediumflow/sequential/cellcentered/transport.hh +++ b/dumux/porousmediumflow/sequential/cellcentered/transport.hh @@ -293,7 +293,7 @@ void FVTransport::update(const Scalar t, Scalar& dt, TransportSolutionT updateVec = 0.0; // compute update vector - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { #if HAVE_MPI if (element.partitionType() != Dune::InteriorEntity) @@ -323,7 +323,7 @@ void FVTransport::update(const Scalar t, Scalar& dt, TransportSolutionT } // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { GlobalPosition unitOuterNormal = intersection.centerUnitOuterNormal(); if (switchNormals_) @@ -446,7 +446,7 @@ void FVTransport::updatedTargetDt_(Scalar &dt) dt = std::numeric_limits::max(); // update target time-step-sizes - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { #if HAVE_MPI if (element.partitionType() != Dune::InteriorEntity) @@ -465,7 +465,7 @@ void FVTransport::updatedTargetDt_(Scalar &dt) FaceDt faceDt; // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { int indexInInside = intersection.indexInInside(); @@ -527,7 +527,7 @@ void FVTransport::updatedTargetDt_(Scalar &dt) localDataI.faceTargetDt[it->first] += subCFLFactor_ * it->second; } - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (intersection.neighbor()) { diff --git a/dumux/porousmediumflow/sequential/cellcentered/velocity.hh b/dumux/porousmediumflow/sequential/cellcentered/velocity.hh index 6b1980cc0b15e8d28ddd72f1f5d4de0fadb6fa91..9d75b386f1b1f5f77d7cd86098467c73c87f8076 100644 --- a/dumux/porousmediumflow/sequential/cellcentered/velocity.hh +++ b/dumux/porousmediumflow/sequential/cellcentered/velocity.hh @@ -95,7 +95,7 @@ private: template void FVVelocity::calculateVelocity() { - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // cell information int globalIdxI = problem_.variables().index(element); @@ -103,7 +103,7 @@ void FVVelocity::calculateVelocity() /***** flux term ***********/ // iterate over all faces of the cell - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { /************* handle interior face *****************/ if (intersection.neighbor()) diff --git a/dumux/porousmediumflow/sequential/gridadapt.hh b/dumux/porousmediumflow/sequential/gridadapt.hh index f4a00947de2202dde89c75b414aa181b594d46f1..48f6e77c3bf3e65e64eac659dba52f74790ad6c4 100644 --- a/dumux/porousmediumflow/sequential/gridadapt.hh +++ b/dumux/porousmediumflow/sequential/gridadapt.hh @@ -210,7 +210,7 @@ public: CoarsenMarkerType coarsenMarker; const typename Grid::Traits::LocalIdSet& idSet(problem_.grid().localIdSet()); - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // only mark non-ghost elements if (element.partitionType() == Dune::GhostEntity) @@ -240,7 +240,7 @@ public: } } // coarsen - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // only mark non-ghost elements if (element.partitionType() == Dune::GhostEntity) @@ -257,7 +257,7 @@ public: { // check if coarsening is possible bool coarsenPossible = true; - for(const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for(const auto& intersection : intersections(problem_.gridView(), element)) { if(intersection.neighbor()) { @@ -356,7 +356,7 @@ private: bool checkNeighborsRefine_(const Element &entity, int level = 1) { // this also refines the neighbor elements - for(const auto& intersection : Dune::intersections(problem_.gridView(), entity)) + for(const auto& intersection : intersections(problem_.gridView(), entity)) { if(!intersection.neighbor()) continue; @@ -400,14 +400,14 @@ private: { // run through all cells done=true; - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // only mark non-ghost elements if (element.partitionType() == Dune::GhostEntity) continue; // run through all neighbor-cells (intersections) - for (const auto& intersection : Dune::intersections(leafGridView, element)) + for (const auto& intersection : intersections(leafGridView, element)) { if(!intersection.neighbor()) continue; diff --git a/dumux/porousmediumflow/sequential/gridadaptinitializationindicator.hh b/dumux/porousmediumflow/sequential/gridadaptinitializationindicator.hh index b5c7c30550a89997b4a5bb1f666a9255f97cfec1..b12090fa6c12e7f3ca4f72cbf5a5ae5dfe4d60b7 100644 --- a/dumux/porousmediumflow/sequential/gridadaptinitializationindicator.hh +++ b/dumux/porousmediumflow/sequential/gridadaptinitializationindicator.hh @@ -236,7 +236,7 @@ public: // 1) calculate Indicator -> min, maxvalues // Schleife über alle Leaf-Elemente - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { int globalIdxI = problem_.variables().index(element); @@ -268,7 +268,7 @@ public: if (indicatorVector_[globalIdxI] != refineCell && (refineAtDirichletBC_ || refineAtFluxBC_)) { // Berechne Verfeinerungsindikator an allen Zellen - for (const auto& intersection : Dune::intersections(problem_.gridView(), element)) + for (const auto& intersection : intersections(problem_.gridView(), element)) { if (intersection.boundary() && indicatorVector_[globalIdxI] != refineCell) { diff --git a/dumux/porousmediumflow/sequential/impetproblem.hh b/dumux/porousmediumflow/sequential/impetproblem.hh index 1b598046b19d2629cfbbaababfd45d50bee4d367..aad34221fc26372942cfcc56769b54d3f57da535 100644 --- a/dumux/porousmediumflow/sequential/impetproblem.hh +++ b/dumux/porousmediumflow/sequential/impetproblem.hh @@ -107,7 +107,7 @@ public: vtkOutputLevel_(-1) { // calculate the bounding box of the grid view - for (const auto& vertex : Dune::vertices(gridView)) { + for (const auto& vertex : vertices(gridView)) { for (int i=0; ivertexMapper().index(vertex); GlobalPosition globalPos = vertex.geometry().corner(0); @@ -316,7 +316,7 @@ public: this->setInitializationRun(initializationRun_); std::cout<<"El2P_TestProblem: initialized pressure field copied to pInit_"<vertexMapper().index(vertex); pInit_[vIdxGlobal] = -this->model().curSol().base()[vIdxGlobal*2][0]; @@ -789,7 +789,7 @@ public: valueSet = false; // loop over all vertices - for (const auto& vertex : Dune::vertices(gridView_)) + for (const auto& vertex : vertices(gridView_)) { // get global index of current vertex int vIdxGlobal = vertexMapper_.index(vertex); @@ -831,7 +831,7 @@ public: void setPressure(std::vector pInit) { std::cout << "InitialPressSat: setPressure function called" << std::endl; - for (const auto& vertex : Dune::vertices(gridView_)) + for (const auto& vertex : vertices(gridView_)) { int vIdxGlobal = vertexMapper_.index(vertex); pInit_[vIdxGlobal] = -pInit[vIdxGlobal]; diff --git a/test/multidomain/2cnistokes2p2cni/2cnistokes2p2cniproblem.hh b/test/multidomain/2cnistokes2p2cni/2cnistokes2p2cniproblem.hh index a322b57de6e66c99c46e068f48c2de604f32c5f8..b05808c40df5549eca6977862c12e0fd4f7fbeee 100644 --- a/test/multidomain/2cnistokes2p2cni/2cnistokes2p2cniproblem.hh +++ b/test/multidomain/2cnistokes2p2cni/2cnistokes2p2cniproblem.hh @@ -175,7 +175,7 @@ public: mdGrid.startSubDomainMarking(); // subdivide grid in two subdomains - for (const auto& element : Dune::elements(mdGrid.leafGridView())) + for (const auto& element : elements(mdGrid.leafGridView())) { // this is required for parallelization, checks if element is within a partition if (element.partitionType() != Dune::InteriorEntity) diff --git a/test/multidomain/2cnizeroeq2p2cni/2cnizeroeq2p2cniproblem.hh b/test/multidomain/2cnizeroeq2p2cni/2cnizeroeq2p2cniproblem.hh index e8bd4f59befbeb23f9f8a84de656f46759050603..e30ffb212ee6b53baa0e0b2d6cf4f0279922d5c3 100644 --- a/test/multidomain/2cnizeroeq2p2cni/2cnizeroeq2p2cniproblem.hh +++ b/test/multidomain/2cnizeroeq2p2cni/2cnizeroeq2p2cniproblem.hh @@ -160,7 +160,7 @@ public: mdGrid.startSubDomainMarking(); // subdivide grid in two subdomains - for (const auto& element : Dune::elements(mdGrid.leafGridView())) + for (const auto& element : elements(mdGrid.leafGridView())) { // this is required for parallelization checks if element is within a partition if (element.partitionType() != Dune::InteriorEntity) diff --git a/test/multidomain/2cstokes2p2c/2cstokes2p2cproblem.hh b/test/multidomain/2cstokes2p2c/2cstokes2p2cproblem.hh index 257feded9262b80471e7b876568f53f3ff235ee4..391d3a69333ea44a8c0abccfded2fb187daed640 100644 --- a/test/multidomain/2cstokes2p2c/2cstokes2p2cproblem.hh +++ b/test/multidomain/2cstokes2p2c/2cstokes2p2cproblem.hh @@ -174,7 +174,7 @@ public: mdGrid.startSubDomainMarking(); // subdivide grid in two subdomains - for (const auto& element : Dune::elements(mdGrid.leafGridView())) + for (const auto& element : elements(mdGrid.leafGridView())) { // this is required for parallelization, checks if element is within a partition if (element.partitionType() != Dune::InteriorEntity) diff --git a/test/multidomain/2czeroeq2p2c/2czeroeq2p2cproblem.hh b/test/multidomain/2czeroeq2p2c/2czeroeq2p2cproblem.hh index 9bb2b2b4ab577c735e0eb45e58ed2621f4153384..d5dea14c09e31eae7ee2249273d2f56ccc91a56c 100644 --- a/test/multidomain/2czeroeq2p2c/2czeroeq2p2cproblem.hh +++ b/test/multidomain/2czeroeq2p2c/2czeroeq2p2cproblem.hh @@ -158,7 +158,7 @@ public: mdGrid.startSubDomainMarking(); // subdivide grid in two subdomains - for (const auto& element : Dune::elements(mdGrid.leafGridView())) + for (const auto& element : elements(mdGrid.leafGridView())) { // this is required for parallelization // checks if element is within a partition diff --git a/test/porousmediumflow/1p/implicit/1pniconductionproblem.hh b/test/porousmediumflow/1p/implicit/1pniconductionproblem.hh index a94981e1a7e61c10bab976260324fa35c9d931a9..68b8d07ffe835878c90b7d1aaae937b8af0e6f26 100644 --- a/test/porousmediumflow/1p/implicit/1pniconductionproblem.hh +++ b/test/porousmediumflow/1p/implicit/1pniconductionproblem.hh @@ -201,7 +201,7 @@ public: Scalar time = std::max(this->timeManager().time() + this->timeManager().timeStepSize(), 1e-10); - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/test/porousmediumflow/1p/implicit/1pniconvectionproblem.hh b/test/porousmediumflow/1p/implicit/1pniconvectionproblem.hh index a2b29c5a4bb5ceb733c1f5b0f3a85bfeaac02ae7..b62f5c8fe97e5f690b72a778b4294c52e21d0adf 100644 --- a/test/porousmediumflow/1p/implicit/1pniconvectionproblem.hh +++ b/test/porousmediumflow/1p/implicit/1pniconvectionproblem.hh @@ -210,7 +210,7 @@ public: Scalar retardedFrontVelocity = darcyVelocity_*storageW/storageTotal/porosity; std::cout<<"retarded velocity: "<gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/test/porousmediumflow/1p/sequential/resultevaluation.hh b/test/porousmediumflow/1p/sequential/resultevaluation.hh index e66922746bb6340cb5e2c5fd7572ec34798a9282..c9c0afe33993a831c986c3b0c0b1417d697a6e0a 100644 --- a/test/porousmediumflow/1p/sequential/resultevaluation.hh +++ b/test/porousmediumflow/1p/sequential/resultevaluation.hh @@ -98,7 +98,7 @@ public: double denominatorGrad = 0; double numeratorFlux = 0; double denominatorFlux = 0; - for (const auto& element : Dune::elements(gridView)) + for (const auto& element : elements(gridView)) { // element geometry const Geometry& geometry = element.geometry(); @@ -131,7 +131,7 @@ public: int isIdx = -1; Dune::FieldVector fluxVector; Dune::FieldVector exactGradient; - for (const auto& intersection : Dune::intersections(gridView, element)) + for (const auto& intersection : intersections(gridView, element)) { // local number of facet int fIdx = intersection.indexInInside(); diff --git a/test/porousmediumflow/1p/sequential/resultevaluation3d.hh b/test/porousmediumflow/1p/sequential/resultevaluation3d.hh index 5973d1795937a80c63692da89eacf6fa266e7786..606cb9b0a32f6f294b5f7925509aee9a912d5d84 100644 --- a/test/porousmediumflow/1p/sequential/resultevaluation3d.hh +++ b/test/porousmediumflow/1p/sequential/resultevaluation3d.hh @@ -102,7 +102,7 @@ public: uMean = 0; double domainVolume = 0; - for (const auto& element : Dune::elements(gridview)) + for (const auto& element : elements(gridview)) { // get volume double volume = element.geometry().volume(); @@ -155,7 +155,7 @@ public: double numeratorFlux = 0; double denominatorFlux = 0; bool exactOutput = true; - for (const auto& element : Dune::elements(gridview)) + for (const auto& element : elements(gridview)) { // element geometry const Geometry& geometry = element.geometry(); @@ -205,7 +205,7 @@ public: int i = -1; Dune::FieldVector fluxVector; Dune::FieldVector exactGradient; - for (const auto& intersection : Dune::intersections(gridview, element)) + for (const auto& intersection : intersections(gridview, element)) { // local number of facet i = intersection.indexInInside(); @@ -460,7 +460,7 @@ public: double numeratorFluxIn = 0; double denominatorFluxIn = 0; bool exactOutput = true; - for (const auto& element : Dune::elements(gridView)) + for (const auto& element : elements(gridView)) { // element geometry const Geometry& geometry = element.geometry(); @@ -489,7 +489,7 @@ public: // calculate the relative error for inner cells bool bndCell = false; - for (const auto& intersection : Dune::intersections(gridView, element)) + for (const auto& intersection : intersections(gridView, element)) { if (intersection.boundary()) { @@ -527,7 +527,7 @@ public: int isIdx = -1; Dune::FieldVector fluxVector; Dune::FieldVector exactGradient; - for (const auto& intersection : Dune::intersections(gridView, element)) + for (const auto& intersection : intersections(gridView, element)) { // local number of facet int fIdx = intersection.indexInInside(); @@ -713,7 +713,7 @@ public: Scalar maxFlux = -1; Scalar numerator = 0; Scalar denominator = 0; - for (const auto& element : Dune::elements(gridView)) + for (const auto& element : elements(gridView)) { // element geometry const Geometry& geometry = element.geometry(); @@ -748,7 +748,7 @@ public: int i = -1; Dune::FieldVector exactGradient; - for (const auto& intersection : Dune::intersections(gridView, element)) + for (const auto& intersection : intersections(gridView, element)) { // get geometry type of face Dune::GeometryType gtf = intersection.geometryInInside().type(); diff --git a/test/porousmediumflow/1p/sequential/test_1pspatialparams.hh b/test/porousmediumflow/1p/sequential/test_1pspatialparams.hh index 8c6c35390b098233bdf5a45665ae6562ef9a47f6..a4ab72f60b3f0cbb33223b1aa1d227a93e18a627 100644 --- a/test/porousmediumflow/1p/sequential/test_1pspatialparams.hh +++ b/test/porousmediumflow/1p/sequential/test_1pspatialparams.hh @@ -67,7 +67,7 @@ public: delta_ = delta; permeability_.resize(gridView_.size(0)); - for(const auto& element : Dune::elements(gridView_)) + for(const auto& element : elements(gridView_)) { setPermeability_(permeability_[indexSet_.index(element)], element.geometry().center()); } diff --git a/test/porousmediumflow/1p/sequential/test_diffusionproblem.hh b/test/porousmediumflow/1p/sequential/test_diffusionproblem.hh index 2674490effcfe1ad9f56ee64751d177deb6a505d..e7bf53dec0acd7eb0e1a48c01a93cc89bd6ceda5 100644 --- a/test/porousmediumflow/1p/sequential/test_diffusionproblem.hh +++ b/test/porousmediumflow/1p/sequential/test_diffusionproblem.hh @@ -219,7 +219,7 @@ public: { ScalarSolution *exactPressure = this->resultWriter().allocateManagedBuffer(this->gridView().size(0)); - for(const auto& element : Dune::elements(this->gridView())) + for(const auto& element : elements(this->gridView())) { (*exactPressure)[this->elementMapper().index(element)][0] = exact(element.geometry().center()); } diff --git a/test/porousmediumflow/1p/sequential/test_diffusionproblem3d.hh b/test/porousmediumflow/1p/sequential/test_diffusionproblem3d.hh index 8ed21af05274630e48d4e028920f46f4b2cf3c0c..54d652ce36e8b7a6ad604ee568ec079c57464566 100644 --- a/test/porousmediumflow/1p/sequential/test_diffusionproblem3d.hh +++ b/test/porousmediumflow/1p/sequential/test_diffusionproblem3d.hh @@ -171,7 +171,7 @@ public: { ScalarSolution *exactPressure = this->resultWriter().allocateManagedBuffer(this->gridView().size(0)); - for(const auto& element : Dune::elements(this->gridView())) + for(const auto& element : elements(this->gridView())) { (*exactPressure)[this->elementMapper().index(element)][0] = exact(element.geometry().center()); } diff --git a/test/porousmediumflow/1p/sequential/test_diffusionspatialparams.hh b/test/porousmediumflow/1p/sequential/test_diffusionspatialparams.hh index aff66dfd9e5adc3d2bdb20898c284dcb5081954e..0e4345b730d8fe25f0eed792a3b17fae43f1c541 100644 --- a/test/porousmediumflow/1p/sequential/test_diffusionspatialparams.hh +++ b/test/porousmediumflow/1p/sequential/test_diffusionspatialparams.hh @@ -104,7 +104,7 @@ public: delta_ = delta; permeability_.resize(gridView_.size(0)); - for(const auto& element : Dune::elements(gridView_)) + for(const auto& element : elements(gridView_)) { perm(permeability_[indexSet_.index(element)], element.geometry().center()); } @@ -118,7 +118,7 @@ public: ScalarSolution *permXY = writer.allocateManagedBuffer(gridView_.size(0)); ScalarSolution *permYY = writer.allocateManagedBuffer(gridView_.size(0)); - for(const auto& element : Dune::elements(gridView_)) + for(const auto& element : elements(gridView_)) { int eIdxGlobal = indexSet_.index(element); (*permXX)[eIdxGlobal][0] = permeability_[eIdxGlobal][0][0]; diff --git a/test/porousmediumflow/1p2c/implicit/1p2cniconductionproblem.hh b/test/porousmediumflow/1p2c/implicit/1p2cniconductionproblem.hh index 410c452d5a0db31ee085163f25b4fbd9fd1f5056..7afc484701671a5dc4a0beaa12b5870ae893fb26 100644 --- a/test/porousmediumflow/1p2c/implicit/1p2cniconductionproblem.hh +++ b/test/porousmediumflow/1p2c/implicit/1p2cniconductionproblem.hh @@ -215,7 +215,7 @@ public: Scalar time = std::max(this->timeManager().time() + this->timeManager().timeStepSize(), 1e-10); - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/test/porousmediumflow/1p2c/implicit/1p2cniconvectionproblem.hh b/test/porousmediumflow/1p2c/implicit/1p2cniconvectionproblem.hh index c73de2d7b5220321470d1da5625581ff8170791b..c0d753713e15339ff6e73b608e090c4e61ff6cc3 100644 --- a/test/porousmediumflow/1p2c/implicit/1p2cniconvectionproblem.hh +++ b/test/porousmediumflow/1p2c/implicit/1p2cniconvectionproblem.hh @@ -219,7 +219,7 @@ public: Scalar retardedFrontVelocity = darcyVelocity_*storageW/storageTotal/porosity; std::cout<<"retarded velocity: "<gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/test/porousmediumflow/2p/implicit/cc2pcornerpointproblem.hh b/test/porousmediumflow/2p/implicit/cc2pcornerpointproblem.hh index 6cd8eefd64ffcfa67dad4339d2b18f2f28854bff..b69a6f0fd3d69cee5273eda28da26adf526370e9 100644 --- a/test/porousmediumflow/2p/implicit/cc2pcornerpointproblem.hh +++ b/test/porousmediumflow/2p/implicit/cc2pcornerpointproblem.hh @@ -313,7 +313,7 @@ public: ScalarField *permX = this->resultWriter().allocateManagedBuffer(numElements); ScalarField *permZ = this->resultWriter().allocateManagedBuffer(numElements); - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { FVElementGeometry fvGeometry; fvGeometry.update(this->gridView(), element); diff --git a/test/porousmediumflow/2p/sequential/buckleyleverettanalyticsolution.hh b/test/porousmediumflow/2p/sequential/buckleyleverettanalyticsolution.hh index 905242001ebaac53c63c340e636f05fe6cef8470..c96947d06dbaf603fa7c5b2a46d32b6d6a35d6cf 100644 --- a/test/porousmediumflow/2p/sequential/buckleyleverettanalyticsolution.hh +++ b/test/porousmediumflow/2p/sequential/buckleyleverettanalyticsolution.hh @@ -195,7 +195,7 @@ private: Scalar globalVolume = 0; Scalar errorNorm = 0.0; - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get entity int index = problem_.variables().index(element); @@ -237,7 +237,7 @@ private: Scalar xMax = frontParams_[0].second * time; // iterate over vertices and get analytic saturation solution - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get global coordinate of cell center GlobalPosition globalPos = element.geometry().center(); diff --git a/test/porousmediumflow/2p/sequential/mcwhorteranalyticsolution.hh b/test/porousmediumflow/2p/sequential/mcwhorteranalyticsolution.hh index 7d34eb47424baa9bd3d8d0a5b90a93c6ce5d62af..bb59894484ef7432f5f39b5abaf4968eadb1bbf7 100644 --- a/test/porousmediumflow/2p/sequential/mcwhorteranalyticsolution.hh +++ b/test/porousmediumflow/2p/sequential/mcwhorteranalyticsolution.hh @@ -94,7 +94,7 @@ private: Scalar globalVolume = 0; Scalar errorNorm = 0.0; - for (const auto& element : Dune::elements(problem_.gridView())) + for (const auto& element : elements(problem_.gridView())) { // get entity int index = problem_.variables().index(element); @@ -299,7 +299,7 @@ private: // std::cout<<" xf_ = "<bBoxMin().two_norm(); // calculate the bounding box of the grid view - for (const auto& vertex : Dune::vertices(gridView)) { + for (const auto& vertex : vertices(gridView)) { GlobalPosition vertexCoord(vertex.geometry().center()); Scalar dist = vertexCoord.two_norm(); diff --git a/test/porousmediumflow/2p/sequential/test_transportproblem.hh b/test/porousmediumflow/2p/sequential/test_transportproblem.hh index c88bb8a2dd4807d4e8ccb7219565327fd862324f..b6b4bb3438e49ddb6aede79144b850db40a68950 100644 --- a/test/porousmediumflow/2p/sequential/test_transportproblem.hh +++ b/test/porousmediumflow/2p/sequential/test_transportproblem.hh @@ -137,7 +137,7 @@ public: vel[0] = 1e-5; // compute update vector - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { // cell index int eIdxGlobal = this->elementMapper().index(element); @@ -145,7 +145,7 @@ public: CellData& cellData = this->variables().cellData(eIdxGlobal); // run through all intersections with neighbors and boundary - for (const auto& intersection : Dune::intersections(this->gridView(), element)) + for (const auto& intersection : intersections(this->gridView(), element)) { // local number of facet int indexInInside = intersection.indexInInside(); diff --git a/test/porousmediumflow/2pnc/implicit/fuelcellproblem.hh b/test/porousmediumflow/2pnc/implicit/fuelcellproblem.hh index 11189632d551bb520e14028df2cd22f546585203..a06a097eb0653334ed0fb79a4b59d833840365c2 100644 --- a/test/porousmediumflow/2pnc/implicit/fuelcellproblem.hh +++ b/test/porousmediumflow/2pnc/implicit/fuelcellproblem.hh @@ -322,7 +322,7 @@ public: ScalarField *reactionSourceH2O = this->resultWriter().allocateManagedBuffer (numDofs); ScalarField *reactionSourceO2 = this->resultWriter().allocateManagedBuffer (numDofs); - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { FVElementGeometry fvGeometry; fvGeometry.update(this->gridView(), element); diff --git a/test/porousmediumflow/3p/implicit/3pniconductionproblem.hh b/test/porousmediumflow/3p/implicit/3pniconductionproblem.hh index 73fc8efef05b40981193989e22765f707c84375f..549b535f105b2c01cdebe7c30020362da8cdeead 100644 --- a/test/porousmediumflow/3p/implicit/3pniconductionproblem.hh +++ b/test/porousmediumflow/3p/implicit/3pniconductionproblem.hh @@ -204,7 +204,7 @@ public: Scalar time = std::max(this->timeManager().time() + this->timeManager().timeStepSize(), 1e-10); - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/test/porousmediumflow/3p/implicit/3pniconvectionproblem.hh b/test/porousmediumflow/3p/implicit/3pniconvectionproblem.hh index e4ca5e69f24858c6bf4827c17ad7f13ae27d730e..90ce0bdc11ab3c2b095b972062793e47a57be5a2 100644 --- a/test/porousmediumflow/3p/implicit/3pniconvectionproblem.hh +++ b/test/porousmediumflow/3p/implicit/3pniconvectionproblem.hh @@ -210,7 +210,7 @@ public: Scalar retardedFrontVelocity = darcyVelocity_*storageW/storageTotal/porosity; std::cout<<"retarded velocity: "<gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/test/porousmediumflow/3p3c/implicit/columnxylolproblem.hh b/test/porousmediumflow/3p3c/implicit/columnxylolproblem.hh index c69b26b1432182ed3d3bf7fa20f39e9f0eee8f4a..118469524175cf065ee08ddc856bfd772f81da77 100644 --- a/test/porousmediumflow/3p3c/implicit/columnxylolproblem.hh +++ b/test/porousmediumflow/3p3c/implicit/columnxylolproblem.hh @@ -292,7 +292,7 @@ public: FVElementGeometry fvGeometry; - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); diff --git a/test/porousmediumflow/3p3c/implicit/infiltrationproblem.hh b/test/porousmediumflow/3p3c/implicit/infiltrationproblem.hh index 35ea253fb0530aa91336bf10c686df1b52b15aa9..6c94ee7d5d62f76f992ea703a71bc72929391b2f 100644 --- a/test/porousmediumflow/3p3c/implicit/infiltrationproblem.hh +++ b/test/porousmediumflow/3p3c/implicit/infiltrationproblem.hh @@ -351,7 +351,7 @@ public: FVElementGeometry fvGeometry; - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); diff --git a/test/porousmediumflow/3p3c/implicit/kuevetteproblem.hh b/test/porousmediumflow/3p3c/implicit/kuevetteproblem.hh index 0e7e14ad4a40af970483cf369e34f11852627c2f..693121d4bb334e845c58bfac12d6c94b16ad170a 100644 --- a/test/porousmediumflow/3p3c/implicit/kuevetteproblem.hh +++ b/test/porousmediumflow/3p3c/implicit/kuevetteproblem.hh @@ -299,7 +299,7 @@ public: FVElementGeometry fvGeometry; - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); diff --git a/test/porousmediumflow/co2/implicit/heterogeneousproblem.hh b/test/porousmediumflow/co2/implicit/heterogeneousproblem.hh index 5f6df5ba8de10ba92362c56a4ce9d6e2eef2aa1c..04130b70c02d0374d194d1a32c597a99616ab511 100644 --- a/test/porousmediumflow/co2/implicit/heterogeneousproblem.hh +++ b/test/porousmediumflow/co2/implicit/heterogeneousproblem.hh @@ -264,7 +264,7 @@ public: FVElementGeometry fvGeometry; VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { int eIdx = this->elementMapper().index(element); (*rank)[eIdx] = this->gridView().comm().rank(); diff --git a/test/porousmediumflow/co2/implicit/heterogeneousproblemni.hh b/test/porousmediumflow/co2/implicit/heterogeneousproblemni.hh index 293867209249115a1599467fa21956bbc5dab17e..6d10e33efd444858160494fe12d0043ab72ecc06 100644 --- a/test/porousmediumflow/co2/implicit/heterogeneousproblemni.hh +++ b/test/porousmediumflow/co2/implicit/heterogeneousproblemni.hh @@ -271,7 +271,7 @@ public: FVElementGeometry fvGeometry; VolumeVariables volVars; - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { int eIdx = this->elementMapper().index(element); (*rank)[eIdx] = this->gridView().comm().rank(); diff --git a/test/porousmediumflow/co2/implicit/heterogeneousspatialparameters.hh b/test/porousmediumflow/co2/implicit/heterogeneousspatialparameters.hh index 13d0684209b2ad41bda4cfef81c62600a0f338b5..88cb7c3435dddd5d22232469d4053d9485f31669 100644 --- a/test/porousmediumflow/co2/implicit/heterogeneousspatialparameters.hh +++ b/test/porousmediumflow/co2/implicit/heterogeneousspatialparameters.hh @@ -135,7 +135,7 @@ public: int numElements = gridView_.size(0); paramIdx_.resize(numElements); - for (const auto& element : Dune::elements(gridView_)) + for (const auto& element : elements(gridView_)) { int eIdx = gridView_.indexSet().index(element); int param = GridCreator::parameters(element)[0]; diff --git a/test/porousmediumflow/richards/implicit/richardsanalyticalproblem.hh b/test/porousmediumflow/richards/implicit/richardsanalyticalproblem.hh index 81a1a6e9abbded535d48ed5899b1c3d7e1c3c326..06da3f3ddb7aa7335aa16996c3982e9bb15a73e3 100644 --- a/test/porousmediumflow/richards/implicit/richardsanalyticalproblem.hh +++ b/test/porousmediumflow/richards/implicit/richardsanalyticalproblem.hh @@ -342,7 +342,7 @@ public: Scalar l2analytic = 0.0; const Scalar time = this->timeManager().time() + this->timeManager().timeStepSize(); - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { // value from numerical approximation Scalar numericalSolution = diff --git a/test/porousmediumflow/richards/implicit/richardsniconductionproblem.hh b/test/porousmediumflow/richards/implicit/richardsniconductionproblem.hh index 7ae220530ded2a69704e1d02eafbf36490be7b0c..df706668e06677be9739dfb38bbb900b6ecd566d 100644 --- a/test/porousmediumflow/richards/implicit/richardsniconductionproblem.hh +++ b/test/porousmediumflow/richards/implicit/richardsniconductionproblem.hh @@ -187,7 +187,7 @@ public: firstElement, fvGeometry, 0); Scalar time = std::max(this->timeManager().time() + this->timeManager().timeStepSize(), 1e-10); - for (const auto& element : Dune::elements(this->gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx) diff --git a/test/porousmediumflow/richards/implicit/richardsniconvectionproblem.hh b/test/porousmediumflow/richards/implicit/richardsniconvectionproblem.hh index 7548de4ba45d5d828615c7640c9033c9573acfbe..c9b66a728ff6706ac23cc9352c4ea1f41fa39018 100644 --- a/test/porousmediumflow/richards/implicit/richardsniconvectionproblem.hh +++ b/test/porousmediumflow/richards/implicit/richardsniconvectionproblem.hh @@ -198,7 +198,7 @@ public: Scalar retardedFrontVelocity = darcyVelocity_*storageW/storageTotal/porosity; std::cout<<"retarded velocity: "<gridView())) + for (const auto& element : elements(this->gridView())) { fvGeometry.update(this->gridView(), element); for (int scvIdx = 0; scvIdx < fvGeometry.numScv; ++scvIdx)