diff options
author | eschnett <> | 2001-03-01 11:40:00 +0000 |
---|---|---|
committer | eschnett <> | 2001-03-01 11:40:00 +0000 |
commit | 310f0ea48d18866b773136aed11200b6eda6378b (patch) | |
tree | 445d3e34ce8b89812994b6614f7bc9f4acbc7fe2 /Carpet/CarpetSlab |
Initial revision
darcs-hash:20010301114010-f6438-12fb8a9ffcc80e86c0a97e37b5b0dae0dbc59b79.gz
Diffstat (limited to 'Carpet/CarpetSlab')
-rw-r--r-- | Carpet/CarpetSlab/COPYING | 341 | ||||
-rw-r--r-- | Carpet/CarpetSlab/README | 8 | ||||
-rw-r--r-- | Carpet/CarpetSlab/configuration.ccl | 6 | ||||
-rw-r--r-- | Carpet/CarpetSlab/interface.ccl | 97 | ||||
-rw-r--r-- | Carpet/CarpetSlab/param.ccl | 2 | ||||
-rw-r--r-- | Carpet/CarpetSlab/schedule.ccl | 2 | ||||
-rw-r--r-- | Carpet/CarpetSlab/src/make.code.defn | 9 | ||||
-rw-r--r-- | Carpet/CarpetSlab/src/slab.cc | 880 | ||||
-rw-r--r-- | Carpet/CarpetSlab/src/slab.h | 89 | ||||
-rw-r--r-- | Carpet/CarpetSlab/src/slab.hh | 37 |
10 files changed, 1471 insertions, 0 deletions
diff --git a/Carpet/CarpetSlab/COPYING b/Carpet/CarpetSlab/COPYING new file mode 100644 index 000000000..1942c4334 --- /dev/null +++ b/Carpet/CarpetSlab/COPYING @@ -0,0 +1,341 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) 19yy <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; see the file COPYING. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19yy name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/Carpet/CarpetSlab/README b/Carpet/CarpetSlab/README new file mode 100644 index 000000000..ea6ac8893 --- /dev/null +++ b/Carpet/CarpetSlab/README @@ -0,0 +1,8 @@ +Cactus Code Thorn CarpetSlab +Authors : Erik Schnetter <schnetter@uni-tuebingen.de> +CVS info : $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/README,v 1.2 2004/01/25 14:57:30 schnetter Exp $ +-------------------------------------------------------------------------- + +Purpose of the thorn: + +This thorn provides hyperslabbing for Carpet. diff --git a/Carpet/CarpetSlab/configuration.ccl b/Carpet/CarpetSlab/configuration.ccl new file mode 100644 index 000000000..8ff27ef27 --- /dev/null +++ b/Carpet/CarpetSlab/configuration.ccl @@ -0,0 +1,6 @@ +# Configuration definitions for thorn CarpetSlab +# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/configuration.ccl,v 1.5 2004/06/08 21:09:25 schnetter Exp $ + +REQUIRES Carpet CarpetLib + +REQUIRES THORNS: Carpet CarpetLib diff --git a/Carpet/CarpetSlab/interface.ccl b/Carpet/CarpetSlab/interface.ccl new file mode 100644 index 000000000..78a5743da --- /dev/null +++ b/Carpet/CarpetSlab/interface.ccl @@ -0,0 +1,97 @@ +# Interface definition for thorn CarpetSlab +# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/interface.ccl,v 1.12 2004/06/08 21:09:25 schnetter Exp $ + +IMPLEMENTS: Hyperslab + +includes header: slab.h in Hyperslab.h + +uses include header: carpet.hh + +uses include header: bbox.hh +uses include header: bboxset.hh +uses include header: vect.hh + +uses include header: gdata.hh + +uses include header: dh.hh +uses include header: ggf.hh +uses include header: gh.hh + + + +CCTK_INT FUNCTION \ + Hyperslab_Get (CCTK_POINTER_TO_CONST IN cctkGH, \ + CCTK_INT IN mapping_handle, \ + CCTK_INT IN proc, \ + CCTK_INT IN vindex, \ + CCTK_INT IN timelevel, \ + CCTK_INT IN hdatatype, \ + CCTK_POINTER IN hdata) + +CCTK_INT FUNCTION \ + Hyperslab_GetList (CCTK_POINTER_TO_CONST IN cctkGH, \ + CCTK_INT IN mapping_handle, \ + CCTK_INT IN num_arrays, \ + CCTK_INT ARRAY IN procs, \ + CCTK_INT ARRAY IN vindices, \ + CCTK_INT ARRAY IN timelevels, \ + CCTK_INT ARRAY IN hdatatypes, \ + CCTK_POINTER ARRAY IN hdata, \ + CCTK_INT ARRAY OUT retvals) + +#CCTK_INT FUNCTION \ +# Hyperslab_LocalMappingByIndex (CCTK_POINTER_TO_CONST IN cctkGH, \ +# CCTK_INT IN vindex, \ +# CCTK_INT IN hdim, \ +# CCTK_INT ARRAY IN direction, \ +# CCTK_INT ARRAY IN origin, \ +# CCTK_INT ARRAY IN extent, \ +# CCTK_INT ARRAY IN downsample, \ +# CCTK_INT IN table_handle, \ +# CCTK_INT CCTK_FPOINTER IN \ +# conversion_fn (CCTK_INT IN nelems, \ +# CCTK_INT IN src_stride, \ +# CCTK_INT IN dst_stride, \ +# CCTK_INT IN src_type, \ +# CCTK_INT IN dst_type, \ +# CCTK_POINTER_TO_CONST IN from, \ +# CCTK_POINTER IN to), \ +# CCTK_INT ARRAY OUT hsize_local, \ +# CCTK_INT ARRAY OUT hsize_global, \ +# CCTK_INT ARRAY OUT hoffset_global) + +CCTK_INT FUNCTION \ + Hyperslab_GlobalMappingByIndex (CCTK_POINTER_TO_CONST IN cctkGH, \ + CCTK_INT IN vindex, \ + CCTK_INT IN hdim, \ + CCTK_INT ARRAY IN direction, \ + CCTK_INT ARRAY IN origin, \ + CCTK_INT ARRAY IN extent, \ + CCTK_INT ARRAY IN downsample, \ + CCTK_INT IN table_handle, \ + CCTK_INT CCTK_FPOINTER IN \ + conversion_fn (CCTK_INT IN nelems, \ + CCTK_INT IN src_stride, \ + CCTK_INT IN dst_stride, \ + CCTK_INT IN src_type, \ + CCTK_INT IN dst_type, \ + CCTK_POINTER_TO_CONST IN from, \ + CCTK_POINTER IN to), \ + CCTK_INT ARRAY OUT hsize) + +CCTK_INT FUNCTION Hyperslab_FreeMapping (CCTK_INT IN mapping_handle) + + + +PROVIDES FUNCTION Hyperslab_Get \ + WITH CarpetSlab_Get LANGUAGE C +PROVIDES FUNCTION Hyperslab_GetList \ + WITH CarpetSlab_GetList LANGUAGE C +PROVIDES FUNCTION Hyperslab_Get \ + WITH CarpetSlab_Fill LANGUAGE C +PROVIDES FUNCTION Hyperslab_GlobalMappingByIndex \ + WITH CarpetSlab_GlobalMappingByIndex LANGUAGE C +#PROVIDES FUNCTION Hyperslab_LocalMappingByIndex \ +# WITH CarpetSlab_LocalMappingByIndex LANGUAGE C +PROVIDES FUNCTION Hyperslab_FreeMapping \ + WITH CarpetSlab_FreeMapping LANGUAGE C diff --git a/Carpet/CarpetSlab/param.ccl b/Carpet/CarpetSlab/param.ccl new file mode 100644 index 000000000..e4ace55bb --- /dev/null +++ b/Carpet/CarpetSlab/param.ccl @@ -0,0 +1,2 @@ +# Parameter definitions for thorn CarpetSlab +# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/param.ccl,v 1.1 2001/03/01 13:40:10 eschnett Exp $ diff --git a/Carpet/CarpetSlab/schedule.ccl b/Carpet/CarpetSlab/schedule.ccl new file mode 100644 index 000000000..9aeffc07f --- /dev/null +++ b/Carpet/CarpetSlab/schedule.ccl @@ -0,0 +1,2 @@ +# Schedule definitions for thorn CarpetSlab +# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/schedule.ccl,v 1.2 2003/11/05 16:18:39 schnetter Exp $ diff --git a/Carpet/CarpetSlab/src/make.code.defn b/Carpet/CarpetSlab/src/make.code.defn new file mode 100644 index 000000000..880ebcffc --- /dev/null +++ b/Carpet/CarpetSlab/src/make.code.defn @@ -0,0 +1,9 @@ +# Main make.code.defn file for thorn CarpetSlab -*-Makefile-*- +# $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/make.code.defn,v 1.2 2002/10/24 10:53:48 schnetter Exp $ + +# Source files in this directory +SRCS = slab.cc + +# Subdirectories containing source files +SUBDIRS = + diff --git a/Carpet/CarpetSlab/src/slab.cc b/Carpet/CarpetSlab/src/slab.cc new file mode 100644 index 000000000..f734aafb9 --- /dev/null +++ b/Carpet/CarpetSlab/src/slab.cc @@ -0,0 +1,880 @@ +// $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/slab.cc,v 1.20 2004/08/19 06:35:36 schnetter Exp $ + +#include <assert.h> +#include <stdlib.h> +#include <string.h> + +#include <vector> + +#include "cctk.h" + +#include "util_Table.h" + +#include "bbox.hh" +#include "bboxset.hh" +#include "dh.hh" +#include "gdata.hh" +#include "gh.hh" +#include "ggf.hh" +#include "vect.hh" + +#include "carpet.hh" + +#include "slab.hh" + +extern "C" { + static const char* rcsid = "$Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/slab.cc,v 1.20 2004/08/19 06:35:36 schnetter Exp $"; + CCTK_FILEVERSION(Carpet_CarpetSlab_slab_cc); +} + + + +namespace CarpetSlab { + + using namespace Carpet; + + + + // Mapping object + // (just store the mapping) + struct mapping { + int vindex; + int hdim; + vector<int> origin; // [vdim] + vector<int> dirs; // [hdim] + vector<int> stride; // [hdim] + vector<int> length; // [hdim] + }; + + + + int + StoreMapping (mapping * const mp) + { + int const table = Util_TableCreate (UTIL_TABLE_FLAGS_DEFAULT); + assert (table>=0); + int const ierr = Util_TableSetPointer (table, mp, "mapping"); + assert (ierr>=0); + return table; + } + + mapping * + RetrieveMapping (int const table) + { + CCTK_POINTER mp; + int const ierr = Util_TableGetPointer (table, &mp, "mapping"); + assert (ierr>=0); + return (mapping *)mp; + } + + void + DeleteMapping (int const table) + { + int const ierr = Util_TableDestroy (table); + assert (ierr>=0); + } + + + + void + FillSlab (const cGH* const cgh, + const int dest_proc, + const int n, + const int ti, + const int hdim, + const int origin[/*vdim*/], + const int dirs[/*hdim*/], + const int stride[/*hdim*/], + const int length[/*hdim*/], + void* const hdata) + { + int ierr; + + // Check Cactus grid hierarchy + assert (cgh); + + // Check destination processor + assert (dest_proc>=-1 && dest_proc<CCTK_nProcs(cgh)); + + // Check variable index + assert (n>=0 && n<CCTK_NumVars()); + + // Get info about variable + const int group = CCTK_GroupIndexFromVarI(n); + assert (group>=0); + const int n0 = CCTK_FirstVarIndexI(group); + assert (n0>=0); + const int var = n - n0; + assert (var>=0); + + // Get info about group + cGroup gp; + ierr = CCTK_GroupData (group, &gp); + assert (! ierr); + assert (gp.dim<=dim); + assert (CCTK_QueryGroupStorageI(cgh, group)); + const int typesize = CCTK_VarTypeSize(gp.vartype); + assert (typesize>0); + + if (gp.grouptype==CCTK_GF && reflevel==-1) { + CCTK_WARN (0, "It is not possible to use hyperslabbing for a grid function in meta mode or global mode (use singlemap mode instead)"); + } + const int rl = gp.grouptype==CCTK_GF ? reflevel : 0; + + if (gp.grouptype==CCTK_GF && Carpet::map==-1 && maps>1) { + CCTK_WARN (0, "It is not possible to use hyperslabbing for a grid function in level mode when there are multiple maps (use singlemap mode instead, or make sure that there is only one map)"); + } + const int m = gp.grouptype==CCTK_GF ? Carpet::map : 0; + const int oldmap = Carpet::map; + if (gp.grouptype==CCTK_GF && oldmap==-1) { + enter_singlemap_mode(const_cast<cGH*>(cgh), m); + } + + // Check dimension + assert (hdim>=0 && hdim<=gp.dim); + + // Get more info about group + cGroupDynamicData gd; + ierr = CCTK_GroupDynamicData (cgh, group, &gd); + assert (! ierr); + const vect<int,dim> sizes = vect<int,dim>::ref(gd.gsh); + for (int d=0; d<dim; ++d) { + assert (sizes[d] >= 0); + } + + // Check timelevel + const int num_tl = gp.numtimelevels; + assert (ti>=0 && ti<num_tl); + const int tl = -ti; + + // Check origin + for (int d=0; d<dim; ++d) { + assert (origin[d]>=0 && origin[d]<=sizes[d]); + } + + // Check directions + for (int dd=0; dd<hdim; ++dd) { + assert (dirs[dd]>=1 && dirs[dd]<=dim); + } + + // Check stride + for (int dd=0; dd<hdim; ++dd) { + assert (stride[dd]>0); + } + + // Check length + for (int dd=0; dd<hdim; ++dd) { + assert (length[dd]>=0); + } + + // Check extent + for (int dd=0; dd<hdim; ++dd) { + assert (origin[dirs[dd]-1] + length[dd] <= sizes[dirs[dd]]); + } + + // Get insider information about variable + const gh<dim>* myhh; + const dh<dim>* mydd; + const ggf<dim>* myff; + assert (group < (int)arrdata.size()); + myhh = arrdata.at(group).at(m).hh; + assert (myhh); + mydd = arrdata.at(group).at(m).dd; + assert (mydd); + assert (var < (int)arrdata.at(group).at(m).data.size()); + myff = arrdata.at(group).at(m).data.at(var); + assert (myff); + + // Detemine collecting processor + const int collect_proc = dest_proc<0 ? 0 : dest_proc; + + // Determine own rank + const int rank = CCTK_MyProc(cgh); + + // Calculate global size + int totalsize = 1; + for (int dd=0; dd<hdim; ++dd) { + totalsize *= length[dd]; + } + + // Allocate memory + assert (hdata); + if (dest_proc==-1 || rank==dest_proc) { + memset (hdata, 0, totalsize * typesize); + } + + // Get sample data + const gdata<dim>* mydata; + mydata = (*myff)(tl, rl, 0, 0); + + // Stride of data in memory + const vect<int,dim> str = mydata->extent().stride(); + + // Stride of collected data + vect<int,dim> hstr = str; + for (int dd=0; dd<hdim; ++dd) { + hstr[dirs[dd]-1] *= stride[dd]; + } + + // Lower bound of collected data + vect<int,dim> hlb(0); + for (int d=0; d<gp.dim; ++d) { + hlb[d] = origin[d] * str[d]; + } + + // Upper bound of collected data + vect<int,dim> hub = hlb; + for (int dd=0; dd<hdim; ++dd) { + hub[dirs[dd]-1] += (length[dd]-1) * hstr[dirs[dd]-1]; + } + + // Calculate extent to collect + const bbox<int,dim> hextent (hlb, hub, hstr); + assert (hextent.size() == totalsize); + + // Create collector data object + void* myhdata = rank==collect_proc ? hdata : 0; + gdata<dim>* const alldata = mydata->make_typed(-1); + alldata->allocate (hextent, collect_proc, myhdata); + + // Done with the temporary stuff + mydata = 0; + + for (comm_state<dim> state; !state.done(); state.step()) { + + // Loop over all components, copying data from them + BEGIN_LOCAL_COMPONENT_LOOP (cgh, gp.grouptype) { + + // Get data object + mydata = (*myff)(tl, rl, component, mglevel); + + // Calculate overlapping extents + const bboxset<int,dim> myextents + = ((mydd->boxes.at(rl).at(component).at(mglevel).sync_not + | mydd->boxes.at(rl).at(component).at(mglevel).interior) + & hextent); + + // Loop over overlapping extents + for (bboxset<int,dim>::const_iterator ext_iter = myextents.begin(); + ext_iter != myextents.end(); + ++ext_iter) { + + // Copy data + alldata->copy_from (state, mydata, *ext_iter); + + } + + } END_LOCAL_COMPONENT_LOOP; + + } // for step + + // Copy result to all processors + if (dest_proc == -1) { + vector<gdata<dim>*> tmpdata(CCTK_nProcs(cgh)); + vector<comm_state<dim> > state; + + for (int proc=0; proc<CCTK_nProcs(cgh); ++proc) { + if (proc != collect_proc) { + void* myhdata = rank==proc ? hdata : 0; + tmpdata.at(proc) = mydata->make_typed(-1); + tmpdata.at(proc)->allocate (alldata->extent(), proc, myhdata); + tmpdata.at(proc)->copy_from (state.at(proc), alldata, alldata->extent()); + } + } + + for (int proc=0; proc<CCTK_nProcs(cgh); ++proc) { + if (proc != collect_proc) { + tmpdata.at(proc)->copy_from (state.at(proc), alldata, alldata->extent()); + } + } + + for (int proc=0; proc<CCTK_nProcs(cgh); ++proc) { + if (proc != collect_proc) { + tmpdata.at(proc)->copy_from (state.at(proc), alldata, alldata->extent()); + delete tmpdata.at(proc); + } + } + + } // Copy result + + if (gp.grouptype==CCTK_GF && oldmap==-1) { + leave_singlemap_mode(const_cast<cGH*>(cgh)); + } + + delete alldata; + } + + + + void * + GetSlab (const cGH* const cgh, + const int dest_proc, + const int n, + const int ti, + const int hdim, + const int origin[/*vdim*/], + const int dirs[/*hdim*/], + const int stride[/*hdim*/], + const int length[/*hdim*/]) + { + // Check Cactus grid hierarchy + assert (cgh); + + // Check destination processor + assert (dest_proc>=-1 && dest_proc<CCTK_nProcs(cgh)); + + // Check variable index + assert (n>=0 && n<CCTK_NumVars()); + + // Get info about variable + const int group = CCTK_GroupIndexFromVarI(n); + assert (group>=0); + const int n0 = CCTK_FirstVarIndexI(group); + assert (n0>=0); + const int var = n - n0; + assert (var>=0); + + // Get info about group + cGroup gp; + CCTK_GroupData (group, &gp); + assert (gp.dim<=dim); + assert (CCTK_QueryGroupStorageI(cgh, group)); + const int typesize = CCTK_VarTypeSize(gp.vartype); + assert (typesize>0); + + if (gp.grouptype==CCTK_GF && reflevel==-1) { + CCTK_WARN (0, "It is not possible to use hyperslabbing for a grid function in global mode (use singlemap mode instead)"); + } + const int rl = gp.grouptype==CCTK_GF ? reflevel : 0; + + if (gp.grouptype==CCTK_GF && Carpet::map==-1) { + CCTK_WARN (0, "It is not possible to use hyperslabbing for a grid function in level mode (use singlemap mode instead)"); + } + const int m = gp.grouptype==CCTK_GF ? Carpet::map : 0; + + // Check dimension + assert (hdim>=0 && hdim<=gp.dim); + + // Check timelevel + const int num_tl = gp.numtimelevels; + assert (ti>=0 && ti<num_tl); + const int tl = -ti; + + // Check origin +// for (int d=0; d<dim; ++d) { +// assert (origin[d]>=0 && origin[d]<=sizes[d]); +// } + + // Check directions + for (int dd=0; dd<hdim; ++dd) { + assert (dirs[dd]>=1 && dirs[dd]<=dim); + } + + // Check stride + for (int dd=0; dd<hdim; ++dd) { + assert (stride[dd]>0); + } + + // Check length + for (int dd=0; dd<hdim; ++dd) { + assert (length[dd]>=0); + } + + // Check extent +// for (int dd=0; dd<hdim; ++dd) { +// assert (origin[dirs[dd]-1] + length[dd] <= sizes[dirs[dd]]); +// } + + // Get insider information about variable + const gh<dim>* myhh; + const dh<dim>* mydd; + const ggf<dim>* myff; + assert (group < (int)arrdata.size()); + myhh = arrdata.at(group).at(m).hh; + assert (myhh); + mydd = arrdata.at(group).at(m).dd; + assert (mydd); + assert (var < (int)arrdata.at(group).at(m).data.size()); + myff = arrdata.at(group).at(m).data.at(var); + assert (myff); + + // Detemine collecting processor + const int collect_proc = dest_proc<0 ? 0 : dest_proc; + + // Determine own rank + const int rank = CCTK_MyProc(cgh); + + // Calculate global size + int totalsize = 1; + for (int dd=0; dd<hdim; ++dd) { + totalsize *= length[dd]; + } + + // Allocate memory + void* hdata = 0; + if (dest_proc==-1 || rank==dest_proc) { + assert (0); + hdata = malloc(totalsize * typesize); + assert (hdata); + memset (hdata, 0, totalsize * typesize); + } + + // Get sample data + const gdata<dim>* mydata; + mydata = (*myff)(tl, rl, 0, 0); + + // Stride of data in memory + const vect<int,dim> str = mydata->extent().stride(); + + // Stride of collected data + vect<int,dim> hstr = str; + for (int dd=0; dd<hdim; ++dd) { + hstr[dirs[dd]-1] *= stride[dd]; + } + + // Lower bound of collected data + vect<int,dim> hlb(0); + for (int d=0; d<gp.dim; ++d) { + hlb[d] = origin[d] * str[d]; + } + + // Upper bound of collected data + vect<int,dim> hub = hlb; + for (int dd=0; dd<hdim; ++dd) { + hub[dirs[dd]-1] += (length[dd]-1) * hstr[dirs[dd]-1]; + } + + // Calculate extent to collect + const bbox<int,dim> hextent (hlb, hub, hstr); + assert (hextent.size() == totalsize); + + // Create collector data object + void* myhdata = rank==collect_proc ? hdata : 0; + gdata<dim>* const alldata = mydata->make_typed(-1); + alldata->allocate (hextent, collect_proc, myhdata); + + // Done with the temporary stuff + mydata = 0; + + for (comm_state<dim> state; !state.done(); state.step()) { + + // Loop over all components, copying data from them + BEGIN_LOCAL_COMPONENT_LOOP (cgh, gp.grouptype) { + + // Get data object + mydata = (*myff)(tl, rl, component, mglevel); + + // Calculate overlapping extents + const bboxset<int,dim> myextents + = ((mydd->boxes.at(rl).at(component).at(mglevel).sync_not + | mydd->boxes.at(rl).at(component).at(mglevel).interior) + & hextent); + + // Loop over overlapping extents + for (bboxset<int,dim>::const_iterator ext_iter = myextents.begin(); + ext_iter != myextents.end(); + ++ext_iter) { + + // Copy data + alldata->copy_from (state, mydata, *ext_iter); + + } + + } END_LOCAL_COMPONENT_LOOP; + + } // for step + + // Copy result to all processors + if (dest_proc == -1) { + vector<gdata<dim>*> tmpdata(CCTK_nProcs(cgh)); + vector<comm_state<dim> > state; + + for (int proc=0; proc<CCTK_nProcs(cgh); ++proc) { + if (proc != collect_proc) { + void* myhdata = rank==proc ? hdata : 0; + tmpdata.at(proc) = mydata->make_typed(-1); + tmpdata.at(proc)->allocate (alldata->extent(), proc, myhdata); + tmpdata.at(proc)->copy_from (state.at(proc), alldata, alldata->extent()); + } + } + + for (int proc=0; proc<CCTK_nProcs(cgh); ++proc) { + if (proc != collect_proc) { + tmpdata.at(proc)->copy_from (state.at(proc), alldata, alldata->extent()); + } + } + + for (int proc=0; proc<CCTK_nProcs(cgh); ++proc) { + if (proc != collect_proc) { + tmpdata.at(proc)->copy_from (state.at(proc), alldata, alldata->extent()); + delete tmpdata.at(proc); + } + } + + } // Copy result + + delete alldata; + + // Success + return hdata; + } + + + + CCTK_INT + CarpetSlab_Get (CCTK_POINTER_TO_CONST const cctkGH_, + CCTK_INT const mapping_handle, + CCTK_INT const proc, + CCTK_INT const vindex, + CCTK_INT const timelevel, + CCTK_INT const hdatatype, + CCTK_POINTER const hdata) + { + cGH const * const cctkGH = (cGH const *) cctkGH_; + + // Check arguments + assert (cctkGH); + assert (mapping_handle>=0); + assert (proc==-1 || proc>=0 && proc<CCTK_nProcs(cctkGH)); + assert (vindex>=0 && vindex<CCTK_NumVars()); + assert (timelevel>=0); + assert (hdatatype>=0); + assert (hdata); + + // Get mapping + const mapping * const mp = RetrieveMapping (mapping_handle); + assert (mp); + + // Calculate total size + size_t size = 1; + for (size_t d=0; d<(size_t)mp->hdim; ++d) { + size *= mp->length[d]; + } + + // Get type size + size_t const sz = CCTK_VarTypeSize (hdatatype); + assert (sz>0); + + // Forward call + FillSlab (cctkGH, proc, vindex, timelevel, + mp->hdim, + &mp->origin[0], &mp->dirs[0], &mp->stride[0], &mp->length[0], + hdata); + + return 0; + } + + + + CCTK_INT + CarpetSlab_GetList (CCTK_POINTER_TO_CONST const cctkGH_, + CCTK_INT const mapping_handle, + CCTK_INT const num_arrays, + CCTK_INT const * const procs, + CCTK_INT const * const vindices, + CCTK_INT const * const timelevels, + CCTK_INT const * const hdatatypes, + CCTK_POINTER const * const hdata, + CCTK_INT * const retvals) + { + cGH const * const cctkGH = (cGH const *) cctkGH_; + + // Check arguments + assert (cctkGH); + assert (mapping_handle>=0); + assert (num_arrays>=0); + assert (procs); + assert (vindices); + assert (timelevels); + assert (hdatatypes); + assert (hdata); + assert (retvals); + + // Remember whether there were errors + bool everyting_okay = true; + + // Loop over all slabs + for (int n=0; n<num_arrays; ++n) { + // Forward call + retvals[n] = CarpetSlab_Get (cctkGH, mapping_handle, procs[n], + vindices[n], timelevels[n], hdatatypes[n], + hdata[n]); + everyting_okay = everyting_okay && retvals[n]; + } + + return everyting_okay ? 0 : -1; + } + + + + typedef CCTK_INT + (* conversion_fn_ptr) (CCTK_INT const nelems, + CCTK_INT const src_stride, + CCTK_INT const dst_stride, + CCTK_INT const src_type, + CCTK_INT const dst_type, + CCTK_POINTER_TO_CONST const from, + CCTK_POINTER const to); + + + + CCTK_INT + CarpetSlab_LocalMappingByIndex (CCTK_POINTER_TO_CONST const cctkGH_, + CCTK_INT const vindex, + CCTK_INT const hdim, + CCTK_INT const * const direction, + CCTK_INT const * const origin, + CCTK_INT const * const extent, + CCTK_INT const * const downsample_, + CCTK_INT const table_handle, + conversion_fn_ptr const conversion_fn, + CCTK_INT * const hsize_local, + CCTK_INT * const hsize_global, + CCTK_INT * const hoffset_global) + { + CCTK_WARN (0, "not implemented"); + return 0; + } + + + + CCTK_INT + CarpetSlab_GlobalMappingByIndex (CCTK_POINTER_TO_CONST const cctkGH_, + CCTK_INT const vindex, + CCTK_INT const hdim, + CCTK_INT const * const direction, + CCTK_INT const * const origin, + CCTK_INT const * const extent, + CCTK_INT const * const downsample_, + CCTK_INT const table_handle, + conversion_fn_ptr const conversion_fn, + CCTK_INT * const hsize) + { + cGH const * const cctkGH = (cGH const *) cctkGH_; + + // Check arguments + assert (cctkGH); + assert (vindex>=0 && vindex<CCTK_NumVars()); + assert (hdim>=0 && hdim<=dim); + assert (direction); + assert (origin); + assert (extent); + // assert (downsample); + // assert (table_handle>=0); + assert (hsize); + + // Get more information + int const vdim = CCTK_GroupDimFromVarI (vindex); + assert (vdim>=0 && vdim<=dim); + assert (hdim<=vdim); + + // Not implemented + assert (! conversion_fn); + + // Allocate memory + mapping * mp = new mapping; + + // Calculate more convenient representation of the direction + vector<int> dirs(hdim); + for (int d=0; d<hdim; ++d) { + for (int dd=0; dd<vdim; ++dd) { + if (direction[d*vdim+dd]!=0) { + dirs[d] = dd+1; + goto found; + } + } + assert (0); + found:; + for (int dd=0; dd<vdim; ++dd) { + assert ((direction[d*vdim+dd]!=0) == (dirs[d]==dd+1)); + } + for (int dd=0; dd<d; ++dd) { + assert (dirs[dd] != dirs[d]); + } + } + + // Calculate lengths + vector<CCTK_INT> downsample(hdim); + for (int dd=0; dd<hdim; ++dd) { + downsample[dd] = downsample_ ? downsample_[dd] : 1; + if (extent[dd]<0) { + int gsh[dim]; + int ierr = CCTK_GroupgshVI(cctkGH, dim, gsh, vindex); + assert (!ierr); + const int totlen = gsh[dirs[dd]-1]; + assert (totlen>=0); + // Partial argument check + assert (origin[dirs[dd]-1]>=0); + assert (origin[dirs[dd]-1]<=totlen); + assert (downsample[dd]>0); + hsize[dd] = (totlen - origin[dirs[dd]-1]) / downsample[dd]; + } else { + hsize[dd] = extent[dd]; + } + assert (hsize[dd]>=0); + } + + // Store information + mp->vindex = vindex; + mp->hdim = hdim; + mp->origin.resize(vdim); + mp->dirs .resize(hdim); + mp->stride.resize(hdim); + mp->length.resize(hdim); + for (size_t d=0; d<(size_t)vdim; ++d) { + mp->origin[d] = origin[d]; + } + for (size_t d=0; d<(size_t)hdim; ++d) { + mp->dirs[d] = dirs[d]; + mp->stride[d] = downsample[d]; + mp->length[d] = hsize[d]; + } + + return StoreMapping (mp); + } + + + + CCTK_INT + CarpetSlab_FreeMapping (CCTK_INT const mapping_handle) + { + // Check arguments + assert (mapping_handle>=0); + + // Get mapping + mapping * mp = RetrieveMapping (mapping_handle); + assert (mp); + + // Delete storage + DeleteMapping (mapping_handle); + + delete mp; + + return 0; + } + + + + int + Hyperslab_GetHyperslab (const cGH* const GH, + const int target_proc, + const int vindex, + const int vtimelvl, + const int hdim, + const int global_startpoint [/*vdim*/], + const int directions [/*vdim*/], + const int lengths [/*hdim*/], + const int downsample_ [/*hdim*/], + void** const hdata, + int hsize [/*hdim*/]) + { + const int vdim = CCTK_GroupDimFromVarI(vindex); + assert (vdim>=1 && vdim<=dim); + + // Check some arguments + assert (hdim>=0 && hdim<=dim); + + // Check output arguments + assert (hdata); + assert (hsize); + + // Calculate more convenient representation of the direction + int dirs[dim]; // should really be dirs[hdim] + // The following if statement is written according to the + // definition of "dir". + if (hdim==1) { + // 1-dimensional hyperslab + int mydir = 0; + for (int d=0; d<vdim; ++d) { + if (directions[d]!=0) { + mydir = d+1; + break; + } + } + assert (mydir>0); + for (int d=0; d<vdim; ++d) { + if (d == mydir-1) { + assert (directions[d]!=0); + } else { + assert (directions[d]==0); + } + } + dirs[0] = mydir; + } else if (hdim==vdim) { + // vdim-dimensional hyperslab + for (int d=0; d<vdim; ++d) { + dirs[d] = d+1; + } + } else if (hdim==2) { + // 2-dimensional hyperslab with vdim==3 + assert (vdim==3); + int mydir = 0; + for (int d=0; d<vdim; ++d) { + if (directions[d]==0) { + mydir = d+1; + break; + } + } + assert (mydir>0); + for (int d=0; d<vdim; ++d) { + if (d == mydir-1) { + assert (directions[d]==0); + } else { + assert (directions[d]!=0); + } + } + int dd=0; + for (int d=0; d<vdim; ++d) { + if (d != mydir-1) { + dirs[dd] = d+1; + ++dd; + } + } + assert (dd==hdim); + } else { + assert (0); + } + // Fill remaining length + for (int d=vdim; d<dim; ++d) { + dirs[d] = d+1; + } + + // Calculate lengths + vector<int> downsample(hdim); + for (int dd=0; dd<hdim; ++dd) { + if (lengths[dd]<0) { + int gsh[dim]; + int ierr = CCTK_GroupgshVI(GH, dim, gsh, vindex); + assert (!ierr); + const int totlen = gsh[dirs[dd]-1]; + assert (totlen>=0); + // Partial argument check + assert (global_startpoint[dirs[dd]-1]>=0); + assert (global_startpoint[dirs[dd]-1]<=totlen); + downsample[dd] = downsample_ ? downsample_[dd] : 1; + assert (downsample[dd]>0); + hsize[dd] = (totlen - global_startpoint[dirs[dd]-1]) / downsample[dd]; + } else { + hsize[dd] = lengths[dd]; + } + assert (hsize[dd]>=0); + } + + // Get the slab + *hdata = GetSlab (GH, + target_proc, + vindex, + vtimelvl, + hdim, + global_startpoint, + dirs, + &downsample[0], + hsize); + + // Return with success + return 1; + } + + + +} // namespace CarpetSlab diff --git a/Carpet/CarpetSlab/src/slab.h b/Carpet/CarpetSlab/src/slab.h new file mode 100644 index 000000000..6e6bc3029 --- /dev/null +++ b/Carpet/CarpetSlab/src/slab.h @@ -0,0 +1,89 @@ +/* $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/slab.h,v 1.4 2004/01/25 14:57:31 schnetter Exp $ */ + +#ifndef CARPETSLAB_H +#define CARPETSLAB_H + +#include "cctk.h" + +#ifdef __cplusplus +namespace CarpetSlab { + extern "C" { +#endif + + CCTK_INT CarpetSlab_Get (CCTK_POINTER_TO_CONST const cctkGH, + CCTK_INT const mapping_handle, + CCTK_INT const proc, + CCTK_INT const vindex, + CCTK_INT const timelevel, + CCTK_INT const hdatatype, + void * const hdata); + + CCTK_INT CarpetSlab_GetList (CCTK_POINTER_TO_CONST const cctkGH, + CCTK_INT const mapping_handle, + CCTK_INT const num_arrays, + CCTK_INT const * const procs, + CCTK_INT const * const vindices, + CCTK_INT const * const timelevels, + CCTK_INT const * const hdatatypes, + void * const * const hdata, + CCTK_INT * const retvals); + + CCTK_INT CarpetSlab_LocalMappingByIndex (CCTK_POINTER_TO_CONST const cctkGH, + CCTK_INT const vindex, + CCTK_INT const hdim, + CCTK_INT const * const direction, + CCTK_INT const * const origin, + CCTK_INT const * const extent, + CCTK_INT const * const downsample, + CCTK_INT const table_handle, + CCTK_INT (* const conversion_fn) (CCTK_INT const nelems, + CCTK_INT const src_stride, + CCTK_INT const dst_stride, + CCTK_INT const src_type, + CCTK_INT const dst_type, + void const * const from, + void * const to), + CCTK_INT * const hsize_local, + CCTK_INT * const hsize_global, + CCTK_INT * const hoffset_global); + + CCTK_INT CarpetSlab_GlobalMappingByIndex (CCTK_POINTER_TO_CONST const cctkGH, + CCTK_INT const vindex, + CCTK_INT const hdim, + CCTK_INT const * const direction, + CCTK_INT const * const origin, + CCTK_INT const * const extent, + CCTK_INT const * const downsample, + CCTK_INT const table_handle, + CCTK_INT (* const conversion_fn) (CCTK_INT const nelems, + CCTK_INT const src_stride, + CCTK_INT const dst_stride, + CCTK_INT const src_type, + CCTK_INT const dst_type, + void const * const from, + void * const to), + CCTK_INT * const hsize); + + CCTK_INT CarpetSlab_FreeMapping (CCTK_INT const mapping_handle); + + + + /* Old interface -- don't use */ + int Hyperslab_GetHyperslab (const cGH* const GH, + const int target_proc, + const int vindex, + const int vtimelvl, + const int hdim, + const int global_startpoint [/*vdim*/], + const int directions [/*vdim*/], + const int lengths [/*hdim*/], + const int downsample [/*hdim*/], + void** const hdata, + int hsize [/*hdim*/]); + +#ifdef __cplusplus + } /* extern "C" */ +} /* namespace CarpetSlab */ +#endif + +#endif /* !defined(CARPETSLAB_H) */ diff --git a/Carpet/CarpetSlab/src/slab.hh b/Carpet/CarpetSlab/src/slab.hh new file mode 100644 index 000000000..a6259236d --- /dev/null +++ b/Carpet/CarpetSlab/src/slab.hh @@ -0,0 +1,37 @@ +// $Header: /home/eschnett/C/carpet/Carpet/Carpet/CarpetSlab/src/slab.hh,v 1.2 2003/11/05 16:18:39 schnetter Exp $ + +#ifndef CARPETSLAB_HH +#define CARPETSLAB_HH + +#include "cctk.h" + +#include "slab.h" + +namespace CarpetSlab { + + // Non-standard interface -- don't use + void FillSlab (const cGH* const cgh, + const int dest_proc, + const int n, + const int tl, + const int hdim, + const int origin[/*vdim*/], + const int dirs[/*hdim*/], + const int stride[/*hdim*/], + const int length[/*hdim*/], + void* const hdata); + + // Non-standard interface -- don't use + void* GetSlab (const cGH* const cgh, + const int dest_proc, + const int n, + const int tl, + const int hdim, + const int origin[/*vdim*/], + const int dirs[/*hdim*/], + const int stride[/*hdim*/], + const int length[/*hdim*/]); + +} // namespace CarpetSlab + +#endif // !defined(CARPETSLAB_HH) |