Zoltan is added as thirdParty package

thirdParty/Zoltan/src/fort/README

@@ -0,0 +1,68 @@
+# @HEADER
+#
+########################################################################
+#
+#  Zoltan Toolkit for Load-balancing, Partitioning, Ordering and Coloring
+#                  Copyright 2012 Sandia Corporation
+#
+# Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+# the U.S. Government retains certain rights in this software.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# 1. Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the Corporation nor the names of the
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Questions? Contact Karen Devine	kddevin@sandia.gov
+#                    Erik Boman	        egboman@sandia.gov
+#
+########################################################################
+#
+# @HEADER
+
+
+FORT DIRECTORY      -- F90 interface.
+------------------------------------------------------------------------
+
+cwrap.c             --  C wrappers that appropriately manipulate function 
+                        arguments to be passed to F90.
+         
+fwrap.fpp           --  F90 wrappers to Zoltan functions.
+
+ztypes.fpp          --  Definitions of F90 data types used in interface.
+
+zoltan_user_data.f90--  Application specific data types for the (void *)
+                        data pointers passed to the query functions.
+
+sppr.f90            --  Pre-processor program that processes # directives
+                        in *.fpp files to produce *.f90 files.
+
+spprinc.*           --  Architecture and F90 compiler specific definitions.
+
+set*.if             --  Interface definitions for query-function specific
+                        registration functions Zoltan_Set_*_Fn.
+
+set*.fn             --  Query-function specific registration functions
+                        Zoltan_Set_*_fn.

thirdParty/Zoltan/src/fort/cwrap_fmangle.h

@@ -0,0 +1,473 @@
+/* 
+ * @HEADER
+ *
+ * ***********************************************************************
+ *
+ *  Zoltan Toolkit for Load-balancing, Partitioning, Ordering and Coloring
+ *                  Copyright 2012 Sandia Corporation
+ *
+ * Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+ * the U.S. Government retains certain rights in this software.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Corporation nor the names of the
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Questions? Contact Karen Devine	kddevin@sandia.gov
+ *                    Erik Boman	egboman@sandia.gov
+ *
+ * ***********************************************************************
+ *
+ * @HEADER
+ */
+#ifndef CWRAPFMANGLEH_
+#define CWRAPFMANGLEH_
+
+#ifndef TRILINOS_NO_CONFIG_H
+/*--------------------------------------------------------------------*/
+/* Autotools and cmake create a macro to handle the mangling.         */
+
+#include "Zoltan_config.h"
+
+#define Zfw_Initialize                 FC_FUNC_(zfw_initialize,ZFW_INITIALIZE)
+#define Zfw_Initialize1                FC_FUNC_(zfw_initialize1,ZFW_INITIALIZE1)
+#define Zfw_Create                     FC_FUNC_(zfw_create,ZFW_CREATE)
+#define Zfw_Copy                       FC_FUNC_(zfw_copy,ZFW_COPY)
+#define Zfw_Copy_To                    FC_FUNC_(zfw_copy_to,ZFW_COPY_TO)
+#define Zfw_Destroy                    FC_FUNC_(zfw_destroy,ZFW_DESTROY)
+#define Zfw_Align                      FC_FUNC_(zfw_align,ZFW_ALIGN)
+#define Zfw_Memory_Stats               FC_FUNC_(zfw_memory_stats,ZFW_MEMORY_STATS)
+#define Zfw_Set_Fn0f                   FC_FUNC_(zfw_set_fn0f,ZFW_SET_FN0F)
+#define Zfw_Set_Fn1f                   FC_FUNC_(zfw_set_fn1f,ZFW_SET_FN1F)
+#define Zfw_Set_Fn2f                   FC_FUNC_(zfw_set_fn2f,ZFW_SET_FN2F)
+#define Zfw_Set_Fn3f                   FC_FUNC_(zfw_set_fn3f,ZFW_SET_FN3F)
+#define Zfw_Set_Fn4f                   FC_FUNC_(zfw_set_fn4f,ZFW_SET_FN4F)
+#define Zfw_Set_Fn5f                   FC_FUNC_(zfw_set_fn5f,ZFW_SET_FN5F)
+#define Zfw_Set_Fn6f                   FC_FUNC_(zfw_set_fn6f,ZFW_SET_FN6F)
+#define Zfw_Set_Fn7f                   FC_FUNC_(zfw_set_fn7f,ZFW_SET_FN7F)
+#define Zfw_Set_Fn8f                   FC_FUNC_(zfw_set_fn8f,ZFW_SET_FN8F)
+#define Zfw_Set_Fn9f                   FC_FUNC_(zfw_set_fn9f,ZFW_SET_FN9F)
+#define Zfw_Set_FnAf                   FC_FUNC_(zfw_set_fnaf,ZFW_SET_FNAF)
+#define Zfw_Set_FnBf                   FC_FUNC_(zfw_set_fnbf,ZFW_SET_FNBF)
+#define Zfw_Set_Fn0s                   FC_FUNC_(zfw_set_fn0s,ZFW_SET_FN0S)
+#define Zfw_Set_Fn1s                   FC_FUNC_(zfw_set_fn1s,ZFW_SET_FN1S)
+#define Zfw_Set_Fn2s                   FC_FUNC_(zfw_set_fn2s,ZFW_SET_FN2S)
+#define Zfw_Set_Fn3s                   FC_FUNC_(zfw_set_fn3s,ZFW_SET_FN3S)
+#define Zfw_Set_Fn4s                   FC_FUNC_(zfw_set_fn4s,ZFW_SET_FN4S)
+#define Zfw_Set_Fn5s                   FC_FUNC_(zfw_set_fn5s,ZFW_SET_FN5S)
+#define Zfw_Set_Fn6s                   FC_FUNC_(zfw_set_fn6s,ZFW_SET_FN6S)
+#define Zfw_Set_Fn7s                   FC_FUNC_(zfw_set_fn7s,ZFW_SET_FN7S)
+#define Zfw_Set_Fn8s                   FC_FUNC_(zfw_set_fn8s,ZFW_SET_FN8S)
+#define Zfw_Set_Fn9s                   FC_FUNC_(zfw_set_fn9s,ZFW_SET_FN9S)
+#define Zfw_Set_FnAs                   FC_FUNC_(zfw_set_fnas,ZFW_SET_FNAS)
+#define Zfw_Set_FnBs                   FC_FUNC_(zfw_set_fnbs,ZFW_SET_FNBS)
+#define Zfw_Set_Param                  FC_FUNC_(zfw_set_param,ZFW_SET_PARAM)
+#define Zfw_Set_Param_Vec              FC_FUNC_(zfw_set_param_vec,ZFW_SET_PARAM_VEC)
+#define Zfw_LB_Partition               FC_FUNC_(zfw_lb_partition,ZFW_LB_PARTITION)
+#define Zfw_LB_Eval                    FC_FUNC_(zfw_lb_eval,ZFW_LB_EVAL)
+#define Zfw_LB_Set_Part_Sizes          FC_FUNC_(zfw_lb_set_part_sizes,ZFW_LB_SET_PART_SIZES)
+#define Zfw_LB_Point_Assign            FC_FUNC_(zfw_lb_point_assign,ZFW_LB_POINT_ASSIGN)
+#define Zfw_LB_Point_PP_Assign         FC_FUNC_(zfw_lb_point_pp_assign,ZFW_LB_POINT_PP_ASSIGN)
+#define Zfw_LB_Box_Assign              FC_FUNC_(zfw_lb_box_assign,ZFW_LB_BOX_ASSIGN)
+#define Zfw_LB_Box_PP_Assign           FC_FUNC_(zfw_lb_box_pp_assign,ZFW_LB_BOX_PP_ASSIGN)
+#define Zfw_Invert_Lists               FC_FUNC_(zfw_invert_lists,ZFW_INVERT_LISTS)
+#define Zfw_Compute_Destinations       FC_FUNC_(zfw_compute_destinations,ZFW_COMPUTE_DESTINATIONS)
+#define Zfw_Migrate                    FC_FUNC_(zfw_migrate,ZFW_MIGRATE)
+#define Zfw_Help_Migrate               FC_FUNC_(zfw_help_migrate,ZFW_HELP_MIGRATE)
+#define Zfw_Order                      FC_FUNC_(zfw_order,ZFW_ORDER)
+#define Zfw_Color                      FC_FUNC_(zfw_color,ZFW_COLOR)
+#define Zfw_Color_Test                 FC_FUNC_(zfw_color_test,ZFW_COLOR_TEST)
+#define Zfw_Generate_Files             FC_FUNC_(zfw_generate_files,ZFW_GENERATE_FILES)
+#define Zfw_RCB_Box                    FC_FUNC_(zfw_rcb_box,ZFW_RCB_BOX)
+#define Zfw_Register_Fort_Malloc       FC_FUNC_(zfw_register_fort_malloc,ZFW_REGISTER_FORT_MALLOC)
+#define Zfw_Get_Address_int            FC_FUNC_(zfw_get_address_int,ZFW_GET_ADDRESS_INT)
+#define Zfw_Get_Address_struct         FC_FUNC_(zfw_get_address_struct,ZFW_GET_ADDRESS_STRUCT)
+#define Zfw_Get_Wgt_Dim                FC_FUNC_(zfw_get_wgt_dim,ZFW_GET_WGT_DIM)
+#define Zfw_Get_Comm_Dim               FC_FUNC_(zfw_get_comm_dim,ZFW_GET_COMM_DIM)
+#define Zfw_Reftree_Get_Child_Order    FC_FUNC_(zfw_reftree_get_child_order,ZFW_REFTREE_GET_CHILD_ORDER)
+
+#else
+/*--------------------------------------------------------------------*/
+/* procedure name mangling must be done manually                      */
+
+#if defined(FC_FN_LOWER) && defined(FC_FN_NO_UNDER)
+
+#define Zfw_Initialize                 zfw_initialize
+#define Zfw_Initialize1                zfw_initialize1
+#define Zfw_Create                     zfw_create       
+#define Zfw_Copy                       zfw_copy
+#define Zfw_Copy_To                    zfw_copy_to
+#define Zfw_Destroy                    zfw_destroy       
+#define Zfw_Align                      zfw_align       
+#define Zfw_Memory_Stats               zfw_memory_stats       
+#define Zfw_Set_Fn0f                   zfw_set_fn0f
+#define Zfw_Set_Fn1f                   zfw_set_fn1f
+#define Zfw_Set_Fn2f                   zfw_set_fn2f
+#define Zfw_Set_Fn3f                   zfw_set_fn3f
+#define Zfw_Set_Fn4f                   zfw_set_fn4f
+#define Zfw_Set_Fn5f                   zfw_set_fn5f
+#define Zfw_Set_Fn6f                   zfw_set_fn6f
+#define Zfw_Set_Fn7f                   zfw_set_fn7f
+#define Zfw_Set_Fn8f                   zfw_set_fn8f
+#define Zfw_Set_Fn9f                   zfw_set_fn9f
+#define Zfw_Set_FnAf                   zfw_set_fnaf
+#define Zfw_Set_FnBf                   zfw_set_fnbf
+#define Zfw_Set_Fn0s                   zfw_set_fn0s
+#define Zfw_Set_Fn1s                   zfw_set_fn1s
+#define Zfw_Set_Fn2s                   zfw_set_fn2s
+#define Zfw_Set_Fn3s                   zfw_set_fn3s
+#define Zfw_Set_Fn4s                   zfw_set_fn4s
+#define Zfw_Set_Fn5s                   zfw_set_fn5s
+#define Zfw_Set_Fn6s                   zfw_set_fn6s
+#define Zfw_Set_Fn7s                   zfw_set_fn7s
+#define Zfw_Set_Fn8s                   zfw_set_fn8s
+#define Zfw_Set_Fn9s                   zfw_set_fn9s
+#define Zfw_Set_FnAs                   zfw_set_fnas
+#define Zfw_Set_FnBs                   zfw_set_fnbs
+#define Zfw_Set_Param                  zfw_set_param
+#define Zfw_Set_Param_Vec              zfw_set_param_vec
+#define Zfw_LB_Partition               zfw_lb_partition
+#define Zfw_LB_Eval                    zfw_lb_eval
+#define Zfw_LB_Set_Part_Sizes          zfw_lb_set_part_sizes
+#define Zfw_LB_Point_Assign            zfw_lb_point_assign
+#define Zfw_LB_Point_PP_Assign         zfw_lb_point_pp_assign
+#define Zfw_LB_Box_Assign              zfw_lb_box_assign
+#define Zfw_LB_Box_PP_Assign           zfw_lb_box_pp_assign
+#define Zfw_Invert_Lists               zfw_invert_lists
+#define Zfw_Compute_Destinations       zfw_compute_destinations
+#define Zfw_Migrate                    zfw_migrate  
+#define Zfw_Help_Migrate               zfw_help_migrate  
+#define Zfw_Order                      zfw_order  
+#define Zfw_Color                      zfw_color  
+#define Zfw_Color_Test                 zfw_color_test  
+#define Zfw_Generate_Files             zfw_generate_files  
+#define Zfw_RCB_Box                    zfw_rcb_box  
+#define Zfw_Register_Fort_Malloc       zfw_register_fort_malloc
+#define Zfw_Get_Address_int            zfw_get_address_int
+#define Zfw_Get_Address_struct         zfw_get_address_struct
+#define Zfw_Get_Wgt_Dim                zfw_get_wgt_dim
+#define Zfw_Get_Comm_Dim               zfw_get_comm_dim
+#define Zfw_Reftree_Get_Child_Order    zfw_reftree_get_child_order
+
+#elif defined(FC_FN_LOWER) && defined(FC_FN_UNDER)
+
+#define Zfw_Initialize                 zfw_initialize_
+#define Zfw_Initialize1                zfw_initialize1_
+#define Zfw_Create                     zfw_create_
+#define Zfw_Copy                       zfw_copy_
+#define Zfw_Copy_To                    zfw_copy_to_
+#define Zfw_Destroy                    zfw_destroy_
+#define Zfw_Align                      zfw_align_
+#define Zfw_Memory_Stats               zfw_memory_stats_
+#define Zfw_Set_Fn0f                   zfw_set_fn0f_
+#define Zfw_Set_Fn1f                   zfw_set_fn1f_
+#define Zfw_Set_Fn2f                   zfw_set_fn2f_
+#define Zfw_Set_Fn3f                   zfw_set_fn3f_
+#define Zfw_Set_Fn4f                   zfw_set_fn4f_
+#define Zfw_Set_Fn5f                   zfw_set_fn5f_
+#define Zfw_Set_Fn6f                   zfw_set_fn6f_
+#define Zfw_Set_Fn7f                   zfw_set_fn7f_
+#define Zfw_Set_Fn8f                   zfw_set_fn8f_
+#define Zfw_Set_Fn9f                   zfw_set_fn9f_
+#define Zfw_Set_FnAf                   zfw_set_fnaf_
+#define Zfw_Set_FnBf                   zfw_set_fnbf_
+#define Zfw_Set_Fn0s                   zfw_set_fn0s_
+#define Zfw_Set_Fn1s                   zfw_set_fn1s_
+#define Zfw_Set_Fn2s                   zfw_set_fn2s_
+#define Zfw_Set_Fn3s                   zfw_set_fn3s_
+#define Zfw_Set_Fn4s                   zfw_set_fn4s_
+#define Zfw_Set_Fn5s                   zfw_set_fn5s_
+#define Zfw_Set_Fn6s                   zfw_set_fn6s_
+#define Zfw_Set_Fn7s                   zfw_set_fn7s_
+#define Zfw_Set_Fn8s                   zfw_set_fn8s_
+#define Zfw_Set_Fn9s                   zfw_set_fn9s_
+#define Zfw_Set_FnAs                   zfw_set_fnas_
+#define Zfw_Set_FnBs                   zfw_set_fnbs_
+#define Zfw_Set_Param                  zfw_set_param_
+#define Zfw_Set_Param_Vec              zfw_set_param_vec_
+#define Zfw_LB_Partition               zfw_lb_partition_
+#define Zfw_LB_Eval                    zfw_lb_eval_
+#define Zfw_LB_Set_Part_Sizes          zfw_lb_set_part_sizes_
+#define Zfw_LB_Point_Assign            zfw_lb_point_assign_
+#define Zfw_LB_Point_PP_Assign         zfw_lb_point_pp_assign_
+#define Zfw_LB_Box_Assign              zfw_lb_box_assign_
+#define Zfw_LB_Box_PP_Assign           zfw_lb_box_pp_assign_
+#define Zfw_Invert_Lists               zfw_invert_lists_
+#define Zfw_Compute_Destinations       zfw_compute_destinations_
+#define Zfw_Migrate                    zfw_migrate_
+#define Zfw_Help_Migrate               zfw_help_migrate_  
+#define Zfw_Order                      zfw_order_  
+#define Zfw_Color                      zfw_color_  
+#define Zfw_Color_Test                 zfw_color_test_  
+#define Zfw_Generate_Files             zfw_generate_files_ 
+#define Zfw_RCB_Box                    zfw_rcb_box_
+#define Zfw_Register_Fort_Malloc       zfw_register_fort_malloc_
+#define Zfw_Get_Address_int            zfw_get_address_int_
+#define Zfw_Get_Address_struct         zfw_get_address_struct_
+#define Zfw_Get_Wgt_Dim                zfw_get_wgt_dim_
+#define Zfw_Get_Comm_Dim               zfw_get_comm_dim_
+#define Zfw_Reftree_Get_Child_Order    zfw_reftree_get_child_order_
+
+#elif defined(FC_FN_LOWER) && defined(FC_FN_SECOND_UNDER)
+
+#define Zfw_Initialize                 zfw_initialize__
+#define Zfw_Initialize1                zfw_initialize1__
+#define Zfw_Create                     zfw_create__
+#define Zfw_Copy                       zfw_copy__
+#define Zfw_Copy_To                    zfw_copy_to__
+#define Zfw_Destroy                    zfw_destroy__
+#define Zfw_Align                      zfw_align__
+#define Zfw_Memory_Stats               zfw_memory_stats__
+#define Zfw_Set_Fn0f                   zfw_set_fn0f__
+#define Zfw_Set_Fn1f                   zfw_set_fn1f__
+#define Zfw_Set_Fn2f                   zfw_set_fn2f__
+#define Zfw_Set_Fn3f                   zfw_set_fn3f__
+#define Zfw_Set_Fn4f                   zfw_set_fn4f__
+#define Zfw_Set_Fn5f                   zfw_set_fn5f__
+#define Zfw_Set_Fn6f                   zfw_set_fn6f__
+#define Zfw_Set_Fn7f                   zfw_set_fn7f__
+#define Zfw_Set_Fn8f                   zfw_set_fn8f__
+#define Zfw_Set_Fn9f                   zfw_set_fn9f__
+#define Zfw_Set_FnAf                   zfw_set_fnaf__
+#define Zfw_Set_FnBf                   zfw_set_fnbf__
+#define Zfw_Set_Fn0s                   zfw_set_fn0s__
+#define Zfw_Set_Fn1s                   zfw_set_fn1s__
+#define Zfw_Set_Fn2s                   zfw_set_fn2s__
+#define Zfw_Set_Fn3s                   zfw_set_fn3s__
+#define Zfw_Set_Fn4s                   zfw_set_fn4s__
+#define Zfw_Set_Fn5s                   zfw_set_fn5s__
+#define Zfw_Set_Fn6s                   zfw_set_fn6s__
+#define Zfw_Set_Fn7s                   zfw_set_fn7s__
+#define Zfw_Set_Fn8s                   zfw_set_fn8s__
+#define Zfw_Set_Fn9s                   zfw_set_fn9s__
+#define Zfw_Set_FnAs                   zfw_set_fnas__
+#define Zfw_Set_FnBs                   zfw_set_fnbs__
+#define Zfw_Set_Param                  zfw_set_param__
+#define Zfw_Set_Param_Vec              zfw_set_param_vec__
+#define Zfw_LB_Partition               zfw_lb_partition__
+#define Zfw_LB_Eval                    zfw_lb_eval__
+#define Zfw_LB_Set_Part_Sizes          zfw_lb_set_part_sizes__
+#define Zfw_LB_Point_Assign            zfw_lb_point_assign__
+#define Zfw_LB_Point_PP_Assign         zfw_lb_point_pp_assign__
+#define Zfw_LB_Box_Assign              zfw_lb_box_assign__
+#define Zfw_LB_Box_PP_Assign           zfw_lb_box_pp_assign__
+#define Zfw_Invert_Lists               zfw_invert_lists__
+#define Zfw_Compute_Destinations       zfw_compute_destinations__
+#define Zfw_Migrate                    zfw_migrate__
+#define Zfw_Help_Migrate               zfw_help_migrate__
+#define Zfw_Order                      zfw_order__
+#define Zfw_Color                      zfw_color__
+#define Zfw_Color_Test                 zfw_color_test__
+#define Zfw_Generate_Files             zfw_generate_files__
+#define Zfw_RCB_Box                    zfw_rcb_box__
+#define Zfw_Register_Fort_Malloc       zfw_register_fort_malloc__
+#define Zfw_Get_Address_int            zfw_get_address_int__
+#define Zfw_Get_Address_struct         zfw_get_address_struct__
+#define Zfw_Get_Wgt_Dim                zfw_get_wgt_dim__
+#define Zfw_Get_Comm_Dim               zfw_get_comm_dim__
+#define Zfw_Reftree_Get_Child_Order    zfw_reftree_get_child_order__
+
+#elif defined(FC_FN_UPPER) && defined(FC_FN_NO_UNDER)
+
+#define Zfw_Initialize                 ZFW_INITIALIZE
+#define Zfw_Initialize1                ZFW_INITIALIZE1
+#define Zfw_Create                     ZFW_CREATE       
+#define Zfw_Copy                       ZFW_COPY
+#define Zfw_Copy_To                    ZFW_COPY_TO
+#define Zfw_Destroy                    ZFW_DESTROY       
+#define Zfw_Align                      ZFW_ALIGN
+#define Zfw_Memory_Stats               ZFW_MEMORY_STATS  
+#define Zfw_Set_Fn0f                   ZFW_SET_FN0F
+#define Zfw_Set_Fn1f                   ZFW_SET_FN1F
+#define Zfw_Set_Fn2f                   ZFW_SET_FN2F
+#define Zfw_Set_Fn3f                   ZFW_SET_FN3F
+#define Zfw_Set_Fn4f                   ZFW_SET_FN4F
+#define Zfw_Set_Fn5f                   ZFW_SET_FN5F
+#define Zfw_Set_Fn6f                   ZFW_SET_FN6F
+#define Zfw_Set_Fn7f                   ZFW_SET_FN7F
+#define Zfw_Set_Fn8f                   ZFW_SET_FN8F
+#define Zfw_Set_Fn9f                   ZFW_SET_FN9F
+#define Zfw_Set_FnAf                   ZFW_SET_FNAF
+#define Zfw_Set_FnBf                   ZFW_SET_FNBF
+#define Zfw_Set_Fn0s                   ZFW_SET_FN0S
+#define Zfw_Set_Fn1s                   ZFW_SET_FN1S
+#define Zfw_Set_Fn2s                   ZFW_SET_FN2S
+#define Zfw_Set_Fn3s                   ZFW_SET_FN3S
+#define Zfw_Set_Fn4s                   ZFW_SET_FN4S
+#define Zfw_Set_Fn5s                   ZFW_SET_FN5S
+#define Zfw_Set_Fn6s                   ZFW_SET_FN6S
+#define Zfw_Set_Fn7s                   ZFW_SET_FN7S
+#define Zfw_Set_Fn8s                   ZFW_SET_FN8S
+#define Zfw_Set_Fn9s                   ZFW_SET_FN9S
+#define Zfw_Set_FnAs                   ZFW_SET_FNAS
+#define Zfw_Set_FnBs                   ZFW_SET_FNBS
+#define Zfw_Set_Param                  ZFW_SET_PARAM
+#define Zfw_Set_Param_Vec              ZFW_SET_PARAM_VEC
+#define Zfw_LB_Partition               ZFW_LB_PARTITION
+#define Zfw_LB_Eval                    ZFW_LB_EVAL
+#define Zfw_LB_Set_Part_Sizes          ZFW_LB_SET_PART_SIZES
+#define Zfw_LB_Point_Assign            ZFW_LB_POINT_ASSIGN
+#define Zfw_LB_Point_PP_Assign         ZFW_LB_POINT_PP_ASSIGN
+#define Zfw_LB_Box_Assign              ZFW_LB_BOX_ASSIGN
+#define Zfw_LB_Box_PP_Assign           ZFW_LB_BOX_PP_ASSIGN
+#define Zfw_Invert_Lists               ZFW_INVERT_LISTS
+#define Zfw_Compute_Destinations       ZFW_COMPUTE_DESTINATIONS  
+#define Zfw_Migrate                    ZFW_MIGRATE  
+#define Zfw_Help_Migrate               ZFW_HELP_MIGRATE  
+#define Zfw_Order                      ZFW_ORDER  
+#define Zfw_Color                      ZFW_COLOR  
+#define Zfw_Color_Test                 ZFW_COLOR_TEST  
+#define Zfw_Generate_Files             ZFW_GENERATE_FILES  
+#define Zfw_RCB_Box                    ZFW_RCB_BOX  
+#define Zfw_Register_Fort_Malloc       ZFW_REGISTER_FORT_MALLOC
+#define Zfw_Get_Address_int            ZFW_GET_ADDRESS_INT
+#define Zfw_Get_Address_struct         ZFW_GET_ADDRESS_STRUCT
+#define Zfw_Get_Comm_Dim               ZFW_GET_COMM_DIM
+#define Zfw_Reftree_Get_Child_Order    ZFW_REFTREE_GET_CHILD_ORDER
+
+#elif defined(FC_FN_UPPER) && defined(FC_FN_UNDER)
+
+#define Zfw_Initialize                 ZFW_INITIALIZE_
+#define Zfw_Initialize1                ZFW_INITIALIZE1_
+#define Zfw_Create                     ZFW_CREATE_
+#define Zfw_Copy                       ZFW_COPY_
+#define Zfw_Copy_To                    ZFW_COPY_TO_
+#define Zfw_Destroy                    ZFW_DESTROY_
+#define Zfw_Align                      ZFW_ALIGN_
+#define Zfw_Memory_Stats               ZFW_MEMORY_STATS_
+#define Zfw_Set_Fn0f                   ZFW_SET_FN0F_
+#define Zfw_Set_Fn1f                   ZFW_SET_FN1F_
+#define Zfw_Set_Fn2f                   ZFW_SET_FN2F_
+#define Zfw_Set_Fn3f                   ZFW_SET_FN3F_
+#define Zfw_Set_Fn4f                   ZFW_SET_FN4F_
+#define Zfw_Set_Fn5f                   ZFW_SET_FN5F_
+#define Zfw_Set_Fn6f                   ZFW_SET_FN6F_
+#define Zfw_Set_Fn7f                   ZFW_SET_FN7F_
+#define Zfw_Set_Fn8f                   ZFW_SET_FN8F_
+#define Zfw_Set_Fn9f                   ZFW_SET_FN9F_
+#define Zfw_Set_FnAf                   ZFW_SET_FNAF_
+#define Zfw_Set_FnBf                   ZFW_SET_FNBF_
+#define Zfw_Set_Fn0s                   ZFW_SET_FN0S_
+#define Zfw_Set_Fn1s                   ZFW_SET_FN1S_
+#define Zfw_Set_Fn2s                   ZFW_SET_FN2S_
+#define Zfw_Set_Fn3s                   ZFW_SET_FN3S_
+#define Zfw_Set_Fn4s                   ZFW_SET_FN4S_
+#define Zfw_Set_Fn5s                   ZFW_SET_FN5S_
+#define Zfw_Set_Fn6s                   ZFW_SET_FN6S_
+#define Zfw_Set_Fn7s                   ZFW_SET_FN7S_
+#define Zfw_Set_Fn8s                   ZFW_SET_FN8S_
+#define Zfw_Set_Fn9s                   ZFW_SET_FN9S_
+#define Zfw_Set_FnAs                   ZFW_SET_FNAS_
+#define Zfw_Set_FnBs                   ZFW_SET_FNBS_
+#define Zfw_Set_Param                  ZFW_SET_PARAM_
+#define Zfw_Set_Param_Vec              ZFW_SET_PARAM_VEC_
+#define Zfw_LB_Partition               ZFW_LB_PARTITION_
+#define Zfw_LB_Eval                    ZFW_LB_EVAL_
+#define Zfw_LB_Set_Part_Sizes          ZFW_LB_SET_PART_SIZES_
+#define Zfw_LB_Point_Assign            ZFW_LB_POINT_ASSIGN_
+#define Zfw_LB_Point_PP_Assign         ZFW_LB_POINT_PP_ASSIGN_
+#define Zfw_LB_Box_Assign              ZFW_LB_BOX_ASSIGN_
+#define Zfw_LB_Box_PP_Assign           ZFW_LB_BOX_PP_ASSIGN_
+#define Zfw_Invert_Lists               ZFW_INVERT_LISTS_
+#define Zfw_Compute_Destinations       ZFW_COMPUTE_DESTINATIONS_
+#define Zfw_Migrate                    ZFW_MIGRATE_
+#define Zfw_Help_Migrate               ZFW_HELP_MIGRATE_
+#define Zfw_Order                      ZFW_ORDER_
+#define Zfw_Color                      ZFW_COLOR_
+#define Zfw_Color_Test                 ZFW_COLOR_TEST_
+#define Zfw_Generate_Files             ZFW_GENERATE_FILES_
+#define Zfw_RCB_Box                    ZFW_RCB_BOX_
+#define Zfw_Register_Fort_Malloc       ZFW_REGISTER_FORT_MALLOC_
+#define Zfw_Get_Address_int            ZFW_GET_ADDRESS_INT_
+#define Zfw_Get_Address_struct         ZFW_GET_ADDRESS_STRUCT_
+#define Zfw_Get_Comm_Dim               ZFW_GET_COMM_DIM_
+#define Zfw_Reftree_Get_Child_Order    ZFW_REFTREE_GET_CHILD_ORDER_
+
+#elif defined(FC_FN_UPPER) && defined(FC_FN_SECOND_UNDER)
+
+#define Zfw_Initialize                 ZFW_INITIALIZE__
+#define Zfw_Initialize1                ZFW_INITIALIZE1__
+#define Zfw_Create                     ZFW_CREATE__
+#define Zfw_Copy                       ZFW_COPY__
+#define Zfw_Copy_To                    ZFW_COPY_TO__
+#define Zfw_Destroy                    ZFW_DESTROY__
+#define Zfw_Align                      ZFW_ALIGN__
+#define Zfw_Memory_Stats               ZFW_MEMORY_STATS__
+#define Zfw_Set_Fn0f                   ZFW_SET_FN0F__
+#define Zfw_Set_Fn1f                   ZFW_SET_FN1F__
+#define Zfw_Set_Fn2f                   ZFW_SET_FN2F__
+#define Zfw_Set_Fn3f                   ZFW_SET_FN3F__
+#define Zfw_Set_Fn4f                   ZFW_SET_FN4F__
+#define Zfw_Set_Fn5f                   ZFW_SET_FN5F__
+#define Zfw_Set_Fn6f                   ZFW_SET_FN6F__
+#define Zfw_Set_Fn7f                   ZFW_SET_FN7F__
+#define Zfw_Set_Fn8f                   ZFW_SET_FN8F__
+#define Zfw_Set_Fn9f                   ZFW_SET_FN9F__
+#define Zfw_Set_FnAf                   ZFW_SET_FNAF__
+#define Zfw_Set_FnBf                   ZFW_SET_FNBF__
+#define Zfw_Set_Fn0s                   ZFW_SET_FN0S__
+#define Zfw_Set_Fn1s                   ZFW_SET_FN1S__
+#define Zfw_Set_Fn2s                   ZFW_SET_FN2S__
+#define Zfw_Set_Fn3s                   ZFW_SET_FN3S__
+#define Zfw_Set_Fn4s                   ZFW_SET_FN4S__
+#define Zfw_Set_Fn5s                   ZFW_SET_FN5S__
+#define Zfw_Set_Fn6s                   ZFW_SET_FN6S__
+#define Zfw_Set_Fn7s                   ZFW_SET_FN7S__
+#define Zfw_Set_Fn8s                   ZFW_SET_FN8S__
+#define Zfw_Set_Fn9s                   ZFW_SET_FN9S__
+#define Zfw_Set_FnAs                   ZFW_SET_FNAS__
+#define Zfw_Set_FnBs                   ZFW_SET_FNBS__
+#define Zfw_Set_Param                  ZFW_SET_PARAM__
+#define Zfw_Set_Param_Vec              ZFW_SET_PARAM_VEC__
+#define Zfw_LB_Partition               ZFW_LB_PARTITION__
+#define Zfw_LB_Eval                    ZFW_LB_EVAL__
+#define Zfw_LB_Set_Part_Sizes          ZFW_LB_SET_PART_SIZES__
+#define Zfw_LB_Point_Assign            ZFW_LB_POINT_ASSIGN__
+#define Zfw_LB_Point_PP_Assign         ZFW_LB_POINT_PP_ASSIGN__
+#define Zfw_LB_Box_Assign              ZFW_LB_BOX_ASSIGN__
+#define Zfw_LB_Box_PP_Assign           ZFW_LB_BOX_PP_ASSIGN__
+#define Zfw_Invert_Lists               ZFW_INVERT_LISTS__
+#define Zfw_Compute_Destinations       ZFW_COMPUTE_DESTINATIONS__
+#define Zfw_Migrate                    ZFW_MIGRATE__
+#define Zfw_Help_Migrate               ZFW_HELP_MIGRATE__
+#define Zfw_Order                      ZFW_ORDER__
+#define Zfw_Color                      ZFW_COLOR__
+#define Zfw_Color_Test                 ZFW_COLOR_TEST__
+#define Zfw_Generate_Files             ZFW_GENERATE_FILES__
+#define Zfw_RCB_Box                    ZFW_RCB_BOX__
+#define Zfw_Register_Fort_Malloc       ZFW_REGISTER_FORT_MALLOC__
+#define Zfw_Get_Address_int            ZFW_GET_ADDRESS_INT__
+#define Zfw_Get_Address_struct         ZFW_GET_ADDRESS_STRUCT__
+#define Zfw_Get_Comm_Dim               ZFW_GET_COMM_DIM__
+#define Zfw_Reftree_Get_Child_Order    ZFW_REFTREE_GET_CHILD_ORDER__
+
+#else
+#error "Unrecognized Fortran Mangling scheme."
+#endif
+
+#endif
+
+#endif

thirdParty/Zoltan/src/fort/makefile

@@ -0,0 +1,123 @@
+# @HEADER
+#
+########################################################################
+#
+#  Zoltan Toolkit for Load-balancing, Partitioning, Ordering and Coloring
+#                  Copyright 2012 Sandia Corporation
+#
+# Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+# the U.S. Government retains certain rights in this software.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# 1. Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the Corporation nor the names of the
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Questions? Contact Karen Devine	kddevin@sandia.gov
+#                    Erik Boman	        egboman@sandia.gov
+#
+########################################################################
+#
+# @HEADER
+
+ZOD = ../$(ZOLTAN_OBJ_DIR)
+ZOM = $(F90_MODULE_PREFIX)$(ZOD) -I../fort
+
+all: 			$(ZOD)/cwrap.o $(ZOD)/ztypes.o \
+			$(ZOD)/zoltan_user_data.o  \
+			$(ZOD)/fwrap.o 
+
+$(ZOD)/fwrap.o: 	$(ZOD)/ztypes.o  \
+			$(ZOD)/zoltan_user_data.o \
+	 	fwrap.f90 \
+		set_numgeom.if			set_numgeom.fn \
+		set_geommulti.if		set_geommulti.fn \
+		set_geom.if			set_geom.fn \
+		set_numedges.if 		set_numedges.fn \
+		set_numedgesmulti.if 		set_numedgesmulti.fn \
+		set_edgelist.if			set_edgelist.fn \
+		set_edgelistmulti.if		set_edgelistmulti.fn \
+		set_numobj.if 			set_numobj.fn \
+		set_partition.if 		set_partition.fn \
+		set_partitionmulti.if		set_partitionmulti.fn \
+		set_objlist.if			set_objlist.fn \
+		set_firstobj.if			set_firstobj.fn \
+		set_nextobj.if			set_nextobj.fn \
+		set_numborderobj.if		set_numborderobj.fn \
+		set_borderobjlist.if		set_borderobjlist.fn \
+		set_firstborderobj.if		set_firstborderobj.fn \
+		set_nextborderobj.if		set_nextborderobj.fn \
+		set_premigrate.if		set_premigrate.fn \
+		set_midmigrate.if		set_midmigrate.fn \
+		set_postmigrate.if		set_postmigrate.fn \
+		set_objsize.if			set_objsize.fn \
+		set_packobj.if			set_packobj.fn \
+		set_unpackobj.if		set_unpackobj.fn \
+		set_objsizemulti.if		set_objsizemulti.fn \
+		set_packobjmulti.if		set_packobjmulti.fn \
+		set_unpackobjmulti.if		set_unpackobjmulti.fn \
+		set_numchild.if 		set_numchild.fn \
+		set_childweight.if 		set_childweight.fn \
+		set_childlist.if 		set_childlist.fn \
+		set_numcoarseobj.if 		set_numcoarseobj.fn \
+		set_coarseobjlist.if 		set_coarseobjlist.fn \
+		set_firstcoarseobj.if		set_firstcoarseobj.fn \
+		set_nextcoarseobj.if		set_nextcoarseobj.fn \
+		set_hgcs.if			set_hgcs.fn \
+		set_hgsizecs.if			set_hgsizecs.fn \
+		set_hgedgeweights.if		set_hgedgeweights.fn \
+		set_hgsizeedgeweights.if	set_hgsizeedgeweights.fn \
+                set_numfixedobj.if              set_numfixedobj.fn \
+                set_fixedobjlist.if             set_fixedobjlist.fn \
+		set_hiernumlevels.if		set_hiernumlevels.fn \
+		set_hierpartition.if		set_hierpartition.fn \
+		set_hiermethod.if		set_hiermethod.fn 
+	$(F90) -c $(ZOM) fwrap.f90
+	/bin/mv *.o *.mod $(ZOD)
+
+$(ZOD)/zoltan_user_data.o:	zoltan_user_data.f90 \
+			$(ZOD)/ztypes.o
+	$(F90) -c  $(ZOM) zoltan_user_data.f90
+	/bin/mv *.o *.mod $(ZOD)
+
+$(ZOD)/ztypes.o: 	ztypes.f90
+	$(F90) -c  $(ZOM) ztypes.f90
+	/bin/mv *.o *.mod $(ZOD)
+
+
+$(ZOD)/cwrap.o: cwrap.c
+	$(CC) -c cwrap.c
+	/bin/mv *.o $(ZOD)
+
+
+clean:
+	@rm -f $(ZOD)/*.f90 $(ZOD)/*.mod debug V* $(ZOD)/*.vo \
+	      $(ZOD)/cwrap.o \
+	      $(ZOD)/fwrap.o \
+	      $(ZOD)/ztypes.o \
+	      $(ZOD)/zoltan_user_data.o \
+              *.vo *.mod *.dbg \
+	      $(ZOD)/zfdrive 
+	@rm -Rf album

thirdParty/Zoltan/src/fort/set_borderobjlist.fn

@@ -0,0 +1,220 @@
+
+function Zf90_Set_Border_Obj_List_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Border_Obj_List_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy,num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Border_Obj_List_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_BORDER_OBJ_LIST_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Border_Obj_List_Fn0s
+
+
+function Zf90_Set_Border_Obj_List_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Border_Obj_List_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Border_Obj_List_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_BORDER_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Border_Obj_List_Fn1s
+
+
+function Zf90_Set_Border_Obj_List_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Border_Obj_List_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Border_Obj_List_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_BORDER_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Border_Obj_List_Fn2s
+
+
+function Zf90_Set_Border_Obj_List_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Border_Obj_List_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Border_Obj_List_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_BORDER_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Border_Obj_List_Fn3s
+
+
+function Zf90_Set_Border_Obj_List_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Border_Obj_List_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Border_Obj_List_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_BORDER_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Border_Obj_List_Fn4s
+
+
+function Zf90_Set_Border_Obj_List_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Border_Obj_List_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Border_Obj_List_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_BORDER_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Border_Obj_List_Fn5s
+
+
+function Zf90_Set_Border_Obj_List_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Border_Obj_List_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Border_Obj_List_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_BORDER_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Border_Obj_List_Fn6s
+
+
+function Zf90_Set_Border_Obj_List_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Border_Obj_List_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Border_Obj_List_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_BORDER_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Border_Obj_List_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_borderobjlist.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Border_Obj_List_Fn
+   module procedure Zf90_Set_Border_Obj_List_Fn0s
+   module procedure Zf90_Set_Border_Obj_List_Fn1s
+   module procedure Zf90_Set_Border_Obj_List_Fn2s
+   module procedure Zf90_Set_Border_Obj_List_Fn3s
+   module procedure Zf90_Set_Border_Obj_List_Fn4s
+   module procedure Zf90_Set_Border_Obj_List_Fn5s
+   module procedure Zf90_Set_Border_Obj_List_Fn6s
+   module procedure Zf90_Set_Border_Obj_List_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_childlist.fn

@@ -0,0 +1,228 @@
+
+function Zf90_Set_Child_List_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Child_List_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy,num_gid_entries, num_lid_entries, parent_gid, &
+    parent_lid, child_gids, child_lids, assigned, num_vert, vertices, &
+    reftype, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: parent_gid(*), parent_lid(*)
+  integer(Zoltan_INT), intent(out) :: child_gids(*), child_lids(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: reftype, ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_List_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_CHILD_LIST_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Child_List_Fn0s
+
+
+function Zf90_Set_Child_List_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_List_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, parent_gid, &
+    parent_lid, child_gids, child_lids, assigned, num_vert, vertices, &
+    reftype, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: parent_gid(*), parent_lid(*)
+  integer(Zoltan_INT), intent(out) :: child_gids(*), child_lids(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: reftype, ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_List_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_CHILD_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_List_Fn1s
+
+
+function Zf90_Set_Child_List_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_List_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, parent_gid, &
+    parent_lid, child_gids, child_lids, assigned, num_vert, vertices, &
+    reftype, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: parent_gid(*), parent_lid(*)
+  integer(Zoltan_INT), intent(out) :: child_gids(*), child_lids(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: reftype, ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_List_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_CHILD_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_List_Fn2s
+
+
+function Zf90_Set_Child_List_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_List_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, parent_gid, &
+    parent_lid, child_gids, child_lids, assigned, num_vert, vertices, &
+    reftype, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: parent_gid(*), parent_lid(*)
+  integer(Zoltan_INT), intent(out) :: child_gids(*), child_lids(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: reftype, ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_List_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_CHILD_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_List_Fn3s
+
+
+function Zf90_Set_Child_List_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_List_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, parent_gid, &
+    parent_lid, child_gids, child_lids, assigned, num_vert, vertices, &
+    reftype, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: parent_gid(*), parent_lid(*)
+  integer(Zoltan_INT), intent(out) :: child_gids(*), child_lids(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: reftype, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_List_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_CHILD_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_List_Fn4s
+
+
+function Zf90_Set_Child_List_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_List_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data,num_gid_entries, num_lid_entries, parent_gid, &
+    parent_lid, child_gids, child_lids, assigned, num_vert, vertices, &
+    reftype, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: parent_gid(*), parent_lid(*)
+  integer(Zoltan_INT), intent(out) :: child_gids(*), child_lids(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: reftype, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_List_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_CHILD_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_List_Fn5s
+
+
+function Zf90_Set_Child_List_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_List_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, parent_gid, &
+    parent_lid, child_gids, child_lids, assigned, num_vert, vertices, &
+    reftype, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: parent_gid(*), parent_lid(*)
+  integer(Zoltan_INT), intent(out) :: child_gids(*), child_lids(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: reftype, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_List_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_CHILD_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_List_Fn6s
+
+
+function Zf90_Set_Child_List_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_List_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, parent_gid, &
+    parent_lid, child_gids, child_lids, assigned, num_vert, vertices, &
+    reftype, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: parent_gid(*), parent_lid(*)
+  integer(Zoltan_INT), intent(out) :: child_gids(*), child_lids(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: reftype, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_List_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_CHILD_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_List_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_childlist.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Child_List_Fn
+   module procedure Zf90_Set_Child_List_Fn0s
+   module procedure Zf90_Set_Child_List_Fn1s
+   module procedure Zf90_Set_Child_List_Fn2s
+   module procedure Zf90_Set_Child_List_Fn3s
+   module procedure Zf90_Set_Child_List_Fn4s
+   module procedure Zf90_Set_Child_List_Fn5s
+   module procedure Zf90_Set_Child_List_Fn6s
+   module procedure Zf90_Set_Child_List_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_childweight.fn

@@ -0,0 +1,212 @@
+
+function Zf90_Set_Child_Weight_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Child_Weight_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_Weight_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_CHILD_WEIGHT_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Child_Weight_Fn0s
+
+
+function Zf90_Set_Child_Weight_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_Weight_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_Weight_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_CHILD_WEIGHT_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_Weight_Fn1s
+
+
+function Zf90_Set_Child_Weight_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_Weight_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_Weight_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_CHILD_WEIGHT_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_Weight_Fn2s
+
+
+function Zf90_Set_Child_Weight_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_Weight_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_Weight_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_CHILD_WEIGHT_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_Weight_Fn3s
+
+
+function Zf90_Set_Child_Weight_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_Weight_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_Weight_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_CHILD_WEIGHT_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_Weight_Fn4s
+
+
+function Zf90_Set_Child_Weight_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_Weight_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_Weight_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_CHILD_WEIGHT_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_Weight_Fn5s
+
+
+function Zf90_Set_Child_Weight_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_Weight_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_Weight_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_CHILD_WEIGHT_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_Weight_Fn6s
+
+
+function Zf90_Set_Child_Weight_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Child_Weight_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Child_Weight_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_CHILD_WEIGHT_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Child_Weight_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_childweight.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Child_Weight_Fn
+   module procedure Zf90_Set_Child_Weight_Fn0s
+   module procedure Zf90_Set_Child_Weight_Fn1s
+   module procedure Zf90_Set_Child_Weight_Fn2s
+   module procedure Zf90_Set_Child_Weight_Fn3s
+   module procedure Zf90_Set_Child_Weight_Fn4s
+   module procedure Zf90_Set_Child_Weight_Fn5s
+   module procedure Zf90_Set_Child_Weight_Fn6s
+   module procedure Zf90_Set_Child_Weight_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_coarseobjlist.fn

@@ -0,0 +1,220 @@
+
+function Zf90_Set_Coarse_Obj_List_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Coarse_Obj_List_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, &
+    local_id, assigned, num_vert, vertices, in_order, &
+    in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: in_order, ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Coarse_Obj_List_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_COARSE_OBJ_LIST_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Coarse_Obj_List_Fn0s
+
+
+function Zf90_Set_Coarse_Obj_List_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Coarse_Obj_List_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, assigned, num_vert, vertices, in_order, &
+    in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: in_order, ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Coarse_Obj_List_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_COARSE_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Coarse_Obj_List_Fn1s
+
+
+function Zf90_Set_Coarse_Obj_List_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Coarse_Obj_List_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, assigned, num_vert, vertices, in_order, &
+    in_vertex, out_vertex, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: in_order, ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Coarse_Obj_List_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_COARSE_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Coarse_Obj_List_Fn2s
+
+
+function Zf90_Set_Coarse_Obj_List_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Coarse_Obj_List_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, assigned, num_vert, vertices, in_order, &
+    in_vertex, out_vertex, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: in_order, ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Coarse_Obj_List_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_COARSE_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Coarse_Obj_List_Fn3s
+
+
+function Zf90_Set_Coarse_Obj_List_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Coarse_Obj_List_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, assigned, num_vert, vertices, in_order, &
+    in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: in_order, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Coarse_Obj_List_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_COARSE_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Coarse_Obj_List_Fn4s
+
+
+function Zf90_Set_Coarse_Obj_List_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Coarse_Obj_List_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, assigned, num_vert, vertices, in_order, &
+    in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: in_order, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Coarse_Obj_List_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_COARSE_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Coarse_Obj_List_Fn5s
+
+
+function Zf90_Set_Coarse_Obj_List_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Coarse_Obj_List_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, assigned, num_vert, vertices, in_order, &
+    in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: in_order, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Coarse_Obj_List_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_COARSE_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Coarse_Obj_List_Fn6s
+
+
+function Zf90_Set_Coarse_Obj_List_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Coarse_Obj_List_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, assigned, num_vert, vertices, in_order, &
+    in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned(*), num_vert(*), vertices(*)
+  integer(Zoltan_INT), intent(out) :: in_vertex(*), out_vertex(*)
+  integer(Zoltan_INT), intent(out) :: in_order, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Coarse_Obj_List_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_COARSE_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Coarse_Obj_List_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_coarseobjlist.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Coarse_Obj_List_Fn
+   module procedure Zf90_Set_Coarse_Obj_List_Fn0s
+   module procedure Zf90_Set_Coarse_Obj_List_Fn1s
+   module procedure Zf90_Set_Coarse_Obj_List_Fn2s
+   module procedure Zf90_Set_Coarse_Obj_List_Fn3s
+   module procedure Zf90_Set_Coarse_Obj_List_Fn4s
+   module procedure Zf90_Set_Coarse_Obj_List_Fn5s
+   module procedure Zf90_Set_Coarse_Obj_List_Fn6s
+   module procedure Zf90_Set_Coarse_Obj_List_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_edgelist.fn

@@ -0,0 +1,228 @@
+
+function Zf90_Set_Edge_List_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, &
+    local_id, nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Edge_List_Fn0s
+
+
+function Zf90_Set_Edge_List_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Fn1s
+
+
+function Zf90_Set_Edge_List_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Fn2s
+
+
+function Zf90_Set_Edge_List_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Fn3s
+
+
+function Zf90_Set_Edge_List_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Fn4s
+
+
+function Zf90_Set_Edge_List_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Fn5s
+
+
+function Zf90_Set_Edge_List_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Fn6s
+
+
+function Zf90_Set_Edge_List_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_edgelist.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Edge_List_Fn
+   module procedure Zf90_Set_Edge_List_Fn0s
+   module procedure Zf90_Set_Edge_List_Fn1s
+   module procedure Zf90_Set_Edge_List_Fn2s
+   module procedure Zf90_Set_Edge_List_Fn3s
+   module procedure Zf90_Set_Edge_List_Fn4s
+   module procedure Zf90_Set_Edge_List_Fn5s
+   module procedure Zf90_Set_Edge_List_Fn6s
+   module procedure Zf90_Set_Edge_List_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_edgelistmulti.fn

@@ -0,0 +1,236 @@
+
+function Zf90_Set_Edge_List_Multi_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Multi_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, num_obj, &
+                    global_id, local_id, num_edges, &
+                    nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*), num_edges(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Multi_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_MULTI_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Edge_List_Multi_Fn0s
+
+
+function Zf90_Set_Edge_List_Multi_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Multi_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+                    global_id, local_id, num_edges, &
+                    nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*), num_edges(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Multi_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Multi_Fn1s
+
+
+function Zf90_Set_Edge_List_Multi_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Multi_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+                    global_id, local_id, num_edges, &
+                    nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*), num_edges(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Multi_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Multi_Fn2s
+
+
+function Zf90_Set_Edge_List_Multi_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Multi_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+                    global_id, local_id, num_edges, &
+                    nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*), num_edges(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Multi_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Multi_Fn3s
+
+
+function Zf90_Set_Edge_List_Multi_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Multi_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+                    global_id, local_id, num_edges, &
+                    nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*), num_edges(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Multi_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Multi_Fn4s
+
+
+function Zf90_Set_Edge_List_Multi_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Multi_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+                    global_id, local_id, num_edges, &
+                    nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*), num_edges(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Multi_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Multi_Fn5s
+
+
+function Zf90_Set_Edge_List_Multi_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Multi_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+                    global_id, local_id, num_edges, &
+                    nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*), num_edges(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Multi_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Multi_Fn6s
+
+
+function Zf90_Set_Edge_List_Multi_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Edge_List_Multi_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+                    global_id, local_id, num_edges, &
+                    nbor_global_id, nbor_procs, wdim, nbor_ewgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*), num_edges(*)
+  integer(Zoltan_INT), intent(out) :: nbor_global_id(*)
+  integer(Zoltan_INT), intent(out) :: nbor_procs(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: nbor_ewgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Edge_List_Multi_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_EDGE_LIST_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Edge_List_Multi_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_edgelistmulti.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Edge_List_Multi_Fn
+   module procedure Zf90_Set_Edge_List_Multi_Fn0s
+   module procedure Zf90_Set_Edge_List_Multi_Fn1s
+   module procedure Zf90_Set_Edge_List_Multi_Fn2s
+   module procedure Zf90_Set_Edge_List_Multi_Fn3s
+   module procedure Zf90_Set_Edge_List_Multi_Fn4s
+   module procedure Zf90_Set_Edge_List_Multi_Fn5s
+   module procedure Zf90_Set_Edge_List_Multi_Fn6s
+   module procedure Zf90_Set_Edge_List_Multi_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_firstborderobj.fn

@@ -0,0 +1,236 @@
+
+function Zf90_Set_First_Border_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_First_Border_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Border_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_FIRST_BORDER_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_First_Border_Obj_Fn0f
+
+
+function Zf90_Set_First_Border_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Border_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Border_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_FIRST_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Border_Obj_Fn1f
+
+
+function Zf90_Set_First_Border_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Border_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Border_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_FIRST_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Border_Obj_Fn2f
+
+
+function Zf90_Set_First_Border_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Border_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Border_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_FIRST_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Border_Obj_Fn3f
+
+
+function Zf90_Set_First_Border_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Border_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Border_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_FIRST_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Border_Obj_Fn4f
+
+
+function Zf90_Set_First_Border_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Border_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Border_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_FIRST_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Border_Obj_Fn5f
+
+
+function Zf90_Set_First_Border_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Border_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Border_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_FIRST_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Border_Obj_Fn6f
+
+
+function Zf90_Set_First_Border_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Border_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Border_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_FIRST_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Border_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_firstborderobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_First_Border_Obj_Fn
+   module procedure Zf90_Set_First_Border_Obj_Fn0f
+   module procedure Zf90_Set_First_Border_Obj_Fn1f
+   module procedure Zf90_Set_First_Border_Obj_Fn2f
+   module procedure Zf90_Set_First_Border_Obj_Fn3f
+   module procedure Zf90_Set_First_Border_Obj_Fn4f
+   module procedure Zf90_Set_First_Border_Obj_Fn5f
+   module procedure Zf90_Set_First_Border_Obj_Fn6f
+   module procedure Zf90_Set_First_Border_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_firstcoarseobj.fn

@@ -0,0 +1,228 @@
+
+function Zf90_Set_First_Coarse_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_First_Coarse_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, local_id, &
+    assigned, num_vert, vertices, in_order, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert, in_order
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Coarse_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_FIRST_COARSE_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_First_Coarse_Obj_Fn0f
+
+
+function Zf90_Set_First_Coarse_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Coarse_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    assigned, num_vert, vertices, in_order, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert, in_order
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Coarse_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_FIRST_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Coarse_Obj_Fn1f
+
+
+function Zf90_Set_First_Coarse_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Coarse_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    assigned, num_vert, vertices, in_order, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert, in_order
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Coarse_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_FIRST_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Coarse_Obj_Fn2f
+
+
+function Zf90_Set_First_Coarse_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Coarse_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    assigned, num_vert, vertices, in_order, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert, in_order
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Coarse_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_FIRST_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Coarse_Obj_Fn3f
+
+
+function Zf90_Set_First_Coarse_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Coarse_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    assigned, num_vert, vertices, in_order, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert, in_order
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Coarse_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_FIRST_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Coarse_Obj_Fn4f
+
+
+function Zf90_Set_First_Coarse_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Coarse_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    assigned, num_vert, vertices, in_order, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert, in_order
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Coarse_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_FIRST_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Coarse_Obj_Fn5f
+
+
+function Zf90_Set_First_Coarse_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Coarse_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    assigned, num_vert, vertices, in_order, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert, in_order
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Coarse_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_FIRST_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Coarse_Obj_Fn6f
+
+
+function Zf90_Set_First_Coarse_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Coarse_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    assigned, num_vert, vertices, in_order, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert, in_order
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Coarse_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_FIRST_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Coarse_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_firstcoarseobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_First_Coarse_Obj_Fn
+   module procedure Zf90_Set_First_Coarse_Obj_Fn0f
+   module procedure Zf90_Set_First_Coarse_Obj_Fn1f
+   module procedure Zf90_Set_First_Coarse_Obj_Fn2f
+   module procedure Zf90_Set_First_Coarse_Obj_Fn3f
+   module procedure Zf90_Set_First_Coarse_Obj_Fn4f
+   module procedure Zf90_Set_First_Coarse_Obj_Fn5f
+   module procedure Zf90_Set_First_Coarse_Obj_Fn6f
+   module procedure Zf90_Set_First_Coarse_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_firstobj.fn

@@ -0,0 +1,220 @@
+
+function Zf90_Set_First_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_First_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_FIRST_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_First_Obj_Fn0f
+
+
+function Zf90_Set_First_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_FIRST_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Obj_Fn1f
+
+
+function Zf90_Set_First_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_FIRST_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Obj_Fn2f
+
+
+function Zf90_Set_First_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_FIRST_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Obj_Fn3f
+
+
+function Zf90_Set_First_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_FIRST_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Obj_Fn4f
+
+
+function Zf90_Set_First_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_FIRST_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Obj_Fn5f
+
+
+function Zf90_Set_First_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_FIRST_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Obj_Fn6f
+
+
+function Zf90_Set_First_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_First_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_First_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_FIRST_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_First_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_firstobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_First_Obj_Fn
+   module procedure Zf90_Set_First_Obj_Fn0f
+   module procedure Zf90_Set_First_Obj_Fn1f
+   module procedure Zf90_Set_First_Obj_Fn2f
+   module procedure Zf90_Set_First_Obj_Fn3f
+   module procedure Zf90_Set_First_Obj_Fn4f
+   module procedure Zf90_Set_First_Obj_Fn5f
+   module procedure Zf90_Set_First_Obj_Fn6f
+   module procedure Zf90_Set_First_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_fixedobjlist.fn

@@ -0,0 +1,212 @@
+
+function Zf90_Set_Fixed_Obj_List_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Fixed_Obj_List_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_fixed_obj, num_gid_entries, &
+    fixed_gids, fixed_part, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_fixed_obj
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries
+  integer(Zoltan_INT), intent(out) :: fixed_gids(*)
+  integer(Zoltan_INT), intent(out) :: fixed_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Fixed_Obj_List_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_FIXED_OBJ_LIST_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Fixed_Obj_List_Fn0s
+
+
+function Zf90_Set_Fixed_Obj_List_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Fixed_Obj_List_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_fixed_obj, num_gid_entries, &
+    fixed_gids, fixed_part, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_fixed_obj
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(out) :: fixed_gids(*)
+  integer(Zoltan_INT), intent(out) :: fixed_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Fixed_Obj_List_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_FIXED_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Fixed_Obj_List_Fn1s
+
+
+function Zf90_Set_Fixed_Obj_List_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Fixed_Obj_List_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_fixed_obj, num_gid_entries, &
+    fixed_gids, fixed_part, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_fixed_obj
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(out) :: fixed_gids(*)
+  integer(Zoltan_INT), intent(out) :: fixed_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Fixed_Obj_List_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_FIXED_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Fixed_Obj_List_Fn2s
+
+
+function Zf90_Set_Fixed_Obj_List_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Fixed_Obj_List_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_fixed_obj, num_gid_entries, &
+    fixed_gids, fixed_part, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_fixed_obj
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(out) :: fixed_gids(*)
+  integer(Zoltan_INT), intent(out) :: fixed_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Fixed_Obj_List_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_FIXED_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Fixed_Obj_List_Fn3s
+
+
+function Zf90_Set_Fixed_Obj_List_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Fixed_Obj_List_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_fixed_obj, num_gid_entries, &
+    fixed_gids, fixed_part,  ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_fixed_obj
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(out) :: fixed_gids(*)
+  integer(Zoltan_INT), intent(out) :: fixed_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Fixed_Obj_List_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_FIXED_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Fixed_Obj_List_Fn4s
+
+
+function Zf90_Set_Fixed_Obj_List_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Fixed_Obj_List_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_fixed_obj, num_gid_entries, &
+    fixed_gids, fixed_part,  ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_fixed_obj
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(out) :: fixed_gids(*)
+  integer(Zoltan_INT), intent(out) :: fixed_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Fixed_Obj_List_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_FIXED_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Fixed_Obj_List_Fn5s
+
+
+function Zf90_Set_Fixed_Obj_List_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Fixed_Obj_List_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_fixed_obj, num_gid_entries,  &
+    fixed_gids, fixed_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_fixed_obj
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(out) :: fixed_gids(*)
+  integer(Zoltan_INT), intent(out) :: fixed_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Fixed_Obj_List_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_FIXED_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Fixed_Obj_List_Fn6s
+
+
+function Zf90_Set_Fixed_Obj_List_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Fixed_Obj_List_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_fixed_obj, num_gid_entries, &
+    fixed_gids, fixed_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_fixed_obj
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(out) :: fixed_gids(*)
+  integer(Zoltan_INT), intent(out) :: fixed_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Fixed_Obj_List_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_FIXED_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Fixed_Obj_List_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_fixedobjlist.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Fixed_Obj_List_Fn
+   module procedure Zf90_Set_Fixed_Obj_List_Fn0s
+   module procedure Zf90_Set_Fixed_Obj_List_Fn1s
+   module procedure Zf90_Set_Fixed_Obj_List_Fn2s
+   module procedure Zf90_Set_Fixed_Obj_List_Fn3s
+   module procedure Zf90_Set_Fixed_Obj_List_Fn4s
+   module procedure Zf90_Set_Fixed_Obj_List_Fn5s
+   module procedure Zf90_Set_Fixed_Obj_List_Fn6s
+   module procedure Zf90_Set_Fixed_Obj_List_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_geom.fn

@@ -0,0 +1,204 @@
+
+function Zf90_Set_Geom_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, &
+    local_id, geom_vec, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_GEOM_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Geom_Fn0s
+
+
+function Zf90_Set_Geom_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, geom_vec, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Fn1s
+
+
+function Zf90_Set_Geom_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, geom_vec, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Fn2s
+
+
+function Zf90_Set_Geom_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, geom_vec, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Fn3s
+
+
+function Zf90_Set_Geom_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, geom_vec, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Fn4s
+
+
+function Zf90_Set_Geom_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, geom_vec, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Fn5s
+
+
+function Zf90_Set_Geom_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, geom_vec, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Fn6s
+
+
+function Zf90_Set_Geom_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, geom_vec, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_geom.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Geom_Fn
+   module procedure Zf90_Set_Geom_Fn0s
+   module procedure Zf90_Set_Geom_Fn1s
+   module procedure Zf90_Set_Geom_Fn2s
+   module procedure Zf90_Set_Geom_Fn3s
+   module procedure Zf90_Set_Geom_Fn4s
+   module procedure Zf90_Set_Geom_Fn5s
+   module procedure Zf90_Set_Geom_Fn6s
+   module procedure Zf90_Set_Geom_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_geommulti.fn

@@ -0,0 +1,212 @@
+
+function Zf90_Set_Geom_Multi_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Multi_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_dim, geom_vec, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj, num_dim
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Multi_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_GEOM_MULTI_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Geom_Multi_Fn0s
+
+
+function Zf90_Set_Geom_Multi_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Multi_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_dim, geom_vec, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj, num_dim
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Multi_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_GEOM_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Multi_Fn1s
+
+
+function Zf90_Set_Geom_Multi_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Multi_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_dim, geom_vec, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj, num_dim
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Multi_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_GEOM_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Multi_Fn2s
+
+
+function Zf90_Set_Geom_Multi_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Multi_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_dim, geom_vec, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj, num_dim
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Multi_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_GEOM_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Multi_Fn3s
+
+
+function Zf90_Set_Geom_Multi_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Multi_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_dim, geom_vec, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj, num_dim
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Multi_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_GEOM_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Multi_Fn4s
+
+
+function Zf90_Set_Geom_Multi_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Multi_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_dim, geom_vec, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj, num_dim
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Multi_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_GEOM_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Multi_Fn5s
+
+
+function Zf90_Set_Geom_Multi_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Multi_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_dim, geom_vec, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj, num_dim
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Multi_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_GEOM_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Multi_Fn6s
+
+
+function Zf90_Set_Geom_Multi_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Geom_Multi_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_dim, geom_vec, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj, num_dim
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  real(Zoltan_DOUBLE), intent(out) :: geom_vec(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Geom_Multi_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_GEOM_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Geom_Multi_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_geommulti.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Geom_Multi_Fn
+   module procedure Zf90_Set_Geom_Multi_Fn0s
+   module procedure Zf90_Set_Geom_Multi_Fn1s
+   module procedure Zf90_Set_Geom_Multi_Fn2s
+   module procedure Zf90_Set_Geom_Multi_Fn3s
+   module procedure Zf90_Set_Geom_Multi_Fn4s
+   module procedure Zf90_Set_Geom_Multi_Fn5s
+   module procedure Zf90_Set_Geom_Multi_Fn6s
+   module procedure Zf90_Set_Geom_Multi_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_hgcs.fn

@@ -0,0 +1,188 @@
+
+function Zf90_Set_HG_CS_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_HG_CS_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, nrowcol, npins, format, &
+                    rowcol_GID, rowcol_ptr, pin_GID, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, nrowcol, npins, format
+  integer(Zoltan_INT), intent(out) :: rowcol_GID(*), rowcol_ptr(*), pin_GID(*), ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_CS_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_HG_CS_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_HG_CS_Fn0s
+
+
+function Zf90_Set_HG_CS_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_CS_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, nrowcol, npins, format,  &
+                    rowcol_GID, rowcol_ptr, pin_GID, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, nrowcol, npins, format
+  integer(Zoltan_INT), intent(out) :: rowcol_GID(*), rowcol_ptr(*), pin_GID(*), ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_CS_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_HG_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_CS_Fn1s
+
+
+function Zf90_Set_HG_CS_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_CS_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, nrowcol, npins, format,  &
+                    rowcol_GID, rowcol_ptr, pin_GID, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, nrowcol, npins, format
+  integer(Zoltan_INT), intent(out) :: rowcol_GID(*), rowcol_ptr(*), pin_GID(*), ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_CS_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_HG_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_CS_Fn2s
+
+
+function Zf90_Set_HG_CS_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_CS_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, nrowcol, npins, format,  &
+                    rowcol_GID, rowcol_ptr, pin_GID, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, nrowcol, npins, format
+  integer(Zoltan_INT), intent(out) :: rowcol_GID(*), rowcol_ptr(*), pin_GID(*), ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_CS_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_HG_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_CS_Fn3s
+
+
+function Zf90_Set_HG_CS_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_CS_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, nrowcol, npins, format,  &
+                    rowcol_GID, rowcol_ptr, pin_GID, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, nrowcol, npins, format
+  integer(Zoltan_INT), intent(out) :: rowcol_GID(*), rowcol_ptr(*), pin_GID(*), ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_CS_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_HG_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_CS_Fn4s
+
+
+function Zf90_Set_HG_CS_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_CS_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, nrowcol, npins, format,  &
+                    rowcol_GID, rowcol_ptr, pin_GID, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, nrowcol, npins, format
+  integer(Zoltan_INT), intent(out) :: rowcol_GID(*), rowcol_ptr(*), pin_GID(*), ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_CS_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_HG_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_CS_Fn5s
+
+
+function Zf90_Set_HG_CS_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_CS_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, nrowcol, npins, format,  &
+                    rowcol_GID, rowcol_ptr, pin_GID, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, nrowcol, npins, format
+  integer(Zoltan_INT), intent(out) :: rowcol_GID(*), rowcol_ptr(*), pin_GID(*), ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_CS_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_HG_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_CS_Fn6s
+
+
+function Zf90_Set_HG_CS_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_CS_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, nrowcol, npins, format,  &
+                    rowcol_GID, rowcol_ptr, pin_GID, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, nrowcol, npins, format
+  integer(Zoltan_INT), intent(out) :: rowcol_GID(*), rowcol_ptr(*), pin_GID(*), ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_CS_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_HG_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_CS_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_hgcs.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_HG_CS_Fn
+   module procedure Zf90_Set_HG_CS_Fn0s
+   module procedure Zf90_Set_HG_CS_Fn1s
+   module procedure Zf90_Set_HG_CS_Fn2s
+   module procedure Zf90_Set_HG_CS_Fn3s
+   module procedure Zf90_Set_HG_CS_Fn4s
+   module procedure Zf90_Set_HG_CS_Fn5s
+   module procedure Zf90_Set_HG_CS_Fn6s
+   module procedure Zf90_Set_HG_CS_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_hgedgeweights.fn

@@ -0,0 +1,196 @@
+
+function Zf90_Set_HG_Edge_Wts_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_HG_Edge_Wts_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, nedges, ew_dim, &
+                    edge_GID, edge_LID, edge_weight, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, nedges, ew_dim
+  integer(Zoltan_INT), intent(out) :: edge_GID(*), edge_LID(*), ierr
+  real(Zoltan_FLOAT), intent(out) :: edge_weight(*)
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Edge_Wts_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_HG_EDGE_WTS_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_HG_Edge_Wts_Fn0s
+
+
+function Zf90_Set_HG_Edge_Wts_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Edge_Wts_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nedges, ew_dim, &
+                    edge_GID, edge_LID, edge_weight, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, nedges, ew_dim
+  integer(Zoltan_INT), intent(out) :: edge_GID(*), edge_LID(*), ierr
+  real(Zoltan_FLOAT), intent(out) :: edge_weight(*)
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Edge_Wts_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_HG_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Edge_Wts_Fn1s
+
+
+function Zf90_Set_HG_Edge_Wts_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Edge_Wts_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nedges, ew_dim, & 
+                    edge_GID, edge_LID, edge_weight, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, nedges, ew_dim
+  integer(Zoltan_INT), intent(out) :: edge_GID(*), edge_LID(*), ierr
+  real(Zoltan_FLOAT), intent(out) :: edge_weight(*)
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Edge_Wts_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_HG_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Edge_Wts_Fn2s
+
+
+function Zf90_Set_HG_Edge_Wts_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Edge_Wts_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nedges, ew_dim , &
+                    edge_GID, edge_LID, edge_weight, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, nedges, ew_dim
+  integer(Zoltan_INT), intent(out) :: edge_GID(*), edge_LID(*), ierr
+  real(Zoltan_FLOAT), intent(out) :: edge_weight(*)
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Edge_Wts_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_HG_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Edge_Wts_Fn3s
+
+
+function Zf90_Set_HG_Edge_Wts_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Edge_Wts_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nedges, ew_dim , &
+                    edge_GID, edge_LID, edge_weight, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, nedges, ew_dim
+  integer(Zoltan_INT), intent(out) :: edge_GID(*), edge_LID(*), ierr
+  real(Zoltan_FLOAT), intent(out) :: edge_weight(*)
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Edge_Wts_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_HG_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Edge_Wts_Fn4s
+
+
+function Zf90_Set_HG_Edge_Wts_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Edge_Wts_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nedges, ew_dim , &
+                    edge_GID, edge_LID, edge_weight, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, nedges, ew_dim
+  integer(Zoltan_INT), intent(out) :: edge_GID(*), edge_LID(*), ierr
+  real(Zoltan_FLOAT), intent(out) :: edge_weight(*)
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Edge_Wts_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_HG_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Edge_Wts_Fn5s
+
+
+function Zf90_Set_HG_Edge_Wts_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Edge_Wts_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nedges, ew_dim , &
+                    edge_GID, edge_LID, edge_weight, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, nedges, ew_dim
+  integer(Zoltan_INT), intent(out) :: edge_GID(*), edge_LID(*), ierr
+  real(Zoltan_FLOAT), intent(out) :: edge_weight(*)
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Edge_Wts_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_HG_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Edge_Wts_Fn6s
+
+
+function Zf90_Set_HG_Edge_Wts_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Edge_Wts_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, nedges, ew_dim , &
+                    edge_GID, edge_LID, edge_weight, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, nedges, ew_dim
+  integer(Zoltan_INT), intent(out) :: edge_GID(*), edge_LID(*), ierr
+  real(Zoltan_FLOAT), intent(out) :: edge_weight(*)
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Edge_Wts_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_HG_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Edge_Wts_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_hgedgeweights.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_HG_Edge_Wts_Fn
+   module procedure Zf90_Set_HG_Edge_Wts_Fn0s
+   module procedure Zf90_Set_HG_Edge_Wts_Fn1s
+   module procedure Zf90_Set_HG_Edge_Wts_Fn2s
+   module procedure Zf90_Set_HG_Edge_Wts_Fn3s
+   module procedure Zf90_Set_HG_Edge_Wts_Fn4s
+   module procedure Zf90_Set_HG_Edge_Wts_Fn5s
+   module procedure Zf90_Set_HG_Edge_Wts_Fn6s
+   module procedure Zf90_Set_HG_Edge_Wts_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_hgsizecs.fn

@@ -0,0 +1,172 @@
+
+function Zf90_Set_HG_Size_CS_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_CS_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_lists, num_pins, format, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(out) :: num_lists, num_pins, format, ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_CS_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_HG_SIZE_CS_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_HG_Size_CS_Fn0s
+
+
+function Zf90_Set_HG_Size_CS_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_CS_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_lists, num_pins, format, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: num_lists, num_pins, format, ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_CS_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_HG_SIZE_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_CS_Fn1s
+
+
+function Zf90_Set_HG_Size_CS_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_CS_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_lists, num_pins, format, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: num_lists, num_pins, format, ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_CS_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_HG_SIZE_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_CS_Fn2s
+
+
+function Zf90_Set_HG_Size_CS_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_CS_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_lists, num_pins, format, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: num_lists, num_pins, format, ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_CS_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_HG_SIZE_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_CS_Fn3s
+
+
+function Zf90_Set_HG_Size_CS_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_CS_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_lists, num_pins, format, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: num_lists, num_pins, format, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_CS_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_HG_SIZE_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_CS_Fn4s
+
+
+function Zf90_Set_HG_Size_CS_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_CS_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_lists, num_pins, format, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: num_lists, num_pins, format, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_CS_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_HG_SIZE_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_CS_Fn5s
+
+
+function Zf90_Set_HG_Size_CS_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_CS_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_lists, num_pins, format, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: num_lists, num_pins, format, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_CS_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_HG_SIZE_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_CS_Fn6s
+
+
+function Zf90_Set_HG_Size_CS_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_CS_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_lists, num_pins, format, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: num_lists, num_pins, format, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_CS_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_HG_SIZE_CS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_CS_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_hgsizecs.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_HG_Size_CS_Fn
+   module procedure Zf90_Set_HG_Size_CS_Fn0s
+   module procedure Zf90_Set_HG_Size_CS_Fn1s
+   module procedure Zf90_Set_HG_Size_CS_Fn2s
+   module procedure Zf90_Set_HG_Size_CS_Fn3s
+   module procedure Zf90_Set_HG_Size_CS_Fn4s
+   module procedure Zf90_Set_HG_Size_CS_Fn5s
+   module procedure Zf90_Set_HG_Size_CS_Fn6s
+   module procedure Zf90_Set_HG_Size_CS_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_hgsizeedgeweights.fn

@@ -0,0 +1,172 @@
+
+function Zf90_Set_HG_Size_Edge_Wts_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_Edge_Wts_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_edges, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(out) :: num_edges, ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_Edge_Wts_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_HG_SIZE_EDGE_WTS_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_HG_Size_Edge_Wts_Fn0s
+
+
+function Zf90_Set_HG_Size_Edge_Wts_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_Edge_Wts_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_edges, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: num_edges, ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_Edge_Wts_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_HG_SIZE_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_Edge_Wts_Fn1s
+
+
+function Zf90_Set_HG_Size_Edge_Wts_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_Edge_Wts_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_edges, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: num_edges, ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_Edge_Wts_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_HG_SIZE_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_Edge_Wts_Fn2s
+
+
+function Zf90_Set_HG_Size_Edge_Wts_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_Edge_Wts_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_edges, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: num_edges, ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_Edge_Wts_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_HG_SIZE_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_Edge_Wts_Fn3s
+
+
+function Zf90_Set_HG_Size_Edge_Wts_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_Edge_Wts_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_edges, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: num_edges, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_Edge_Wts_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_HG_SIZE_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_Edge_Wts_Fn4s
+
+
+function Zf90_Set_HG_Size_Edge_Wts_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_Edge_Wts_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_edges, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: num_edges, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_Edge_Wts_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_HG_SIZE_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_Edge_Wts_Fn5s
+
+
+function Zf90_Set_HG_Size_Edge_Wts_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_Edge_Wts_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_edges, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: num_edges, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_Edge_Wts_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_HG_SIZE_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_Edge_Wts_Fn6s
+
+
+function Zf90_Set_HG_Size_Edge_Wts_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_HG_Size_Edge_Wts_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_edges, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: num_edges, ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_HG_Size_Edge_Wts_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_HG_SIZE_EDGE_WTS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_HG_Size_Edge_Wts_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_hgsizeedgeweights.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_HG_Size_Edge_Wts_Fn
+   module procedure Zf90_Set_HG_Size_Edge_Wts_Fn0s
+   module procedure Zf90_Set_HG_Size_Edge_Wts_Fn1s
+   module procedure Zf90_Set_HG_Size_Edge_Wts_Fn2s
+   module procedure Zf90_Set_HG_Size_Edge_Wts_Fn3s
+   module procedure Zf90_Set_HG_Size_Edge_Wts_Fn4s
+   module procedure Zf90_Set_HG_Size_Edge_Wts_Fn5s
+   module procedure Zf90_Set_HG_Size_Edge_Wts_Fn6s
+   module procedure Zf90_Set_HG_Size_Edge_Wts_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_hiermethod.fn

@@ -0,0 +1,188 @@
+
+function Zf90_Set_Hier_Method_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Method_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy,level,zz,ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: level
+  type(Zoltan_Struct), intent(in), target :: zz
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Method_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_HIER_METHOD_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Hier_Method_Fn0s
+
+
+function Zf90_Set_Hier_Method_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Method_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data,level,zz,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: level
+  type(Zoltan_Struct), intent(in), target :: zz
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Method_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_HIER_METHOD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Method_Fn1s
+
+
+function Zf90_Set_Hier_Method_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Method_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data,level,zz,ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: level
+  type(Zoltan_Struct), intent(in), target :: zz
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Method_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_HIER_METHOD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Method_Fn2s
+
+
+function Zf90_Set_Hier_Method_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Method_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data,level,zz,ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: level
+  type(Zoltan_Struct), intent(in), target :: zz
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Method_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_HIER_METHOD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Method_Fn3s
+
+
+function Zf90_Set_Hier_Method_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Method_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data,level,zz,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: level
+  type(Zoltan_Struct), intent(in), target :: zz
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Method_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_HIER_METHOD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Method_Fn4s
+
+
+function Zf90_Set_Hier_Method_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Method_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data,level,zz,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: level
+  type(Zoltan_Struct), intent(in), target :: zz
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Method_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_HIER_METHOD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Method_Fn5s
+
+
+function Zf90_Set_Hier_Method_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Method_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data,level,zz,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: level
+  type(Zoltan_Struct), intent(in), target :: zz
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Method_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_HIER_METHOD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Method_Fn6s
+
+
+function Zf90_Set_Hier_Method_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Method_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data,level,zz,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: level
+  type(Zoltan_Struct), intent(in), target :: zz
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Method_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_HIER_METHOD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Method_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_hiermethod.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Hier_Method_Fn
+   module procedure Zf90_Set_Hier_Method_Fn0s
+   module procedure Zf90_Set_Hier_Method_Fn1s
+   module procedure Zf90_Set_Hier_Method_Fn2s
+   module procedure Zf90_Set_Hier_Method_Fn3s
+   module procedure Zf90_Set_Hier_Method_Fn4s
+   module procedure Zf90_Set_Hier_Method_Fn5s
+   module procedure Zf90_Set_Hier_Method_Fn6s
+   module procedure Zf90_Set_Hier_Method_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_hiernumlevels.fn

@@ -0,0 +1,180 @@
+
+function Zf90_Set_Hier_Num_Levels_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Num_Levels_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Num_Levels_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_HIER_NUM_LEVELS_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Hier_Num_Levels_Fn0f
+
+
+function Zf90_Set_Hier_Num_Levels_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Num_Levels_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Num_Levels_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_HIER_NUM_LEVELS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Num_Levels_Fn1f
+
+
+function Zf90_Set_Hier_Num_Levels_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Num_Levels_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Num_Levels_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_HIER_NUM_LEVELS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Num_Levels_Fn2f
+
+
+function Zf90_Set_Hier_Num_Levels_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Num_Levels_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Num_Levels_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_HIER_NUM_LEVELS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Num_Levels_Fn3f
+
+
+function Zf90_Set_Hier_Num_Levels_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Num_Levels_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Num_Levels_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_HIER_NUM_LEVELS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Num_Levels_Fn4f
+
+
+function Zf90_Set_Hier_Num_Levels_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Num_Levels_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Num_Levels_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_HIER_NUM_LEVELS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Num_Levels_Fn5f
+
+
+function Zf90_Set_Hier_Num_Levels_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Num_Levels_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Num_Levels_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_HIER_NUM_LEVELS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Num_Levels_Fn6f
+
+
+function Zf90_Set_Hier_Num_Levels_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Num_Levels_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Num_Levels_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_HIER_NUM_LEVELS_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Num_Levels_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_hiernumlevels.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Hier_Num_Levels_Fn
+   module procedure Zf90_Set_Hier_Num_Levels_Fn0f
+   module procedure Zf90_Set_Hier_Num_Levels_Fn1f
+   module procedure Zf90_Set_Hier_Num_Levels_Fn2f
+   module procedure Zf90_Set_Hier_Num_Levels_Fn3f
+   module procedure Zf90_Set_Hier_Num_Levels_Fn4f
+   module procedure Zf90_Set_Hier_Num_Levels_Fn5f
+   module procedure Zf90_Set_Hier_Num_Levels_Fn6f
+   module procedure Zf90_Set_Hier_Num_Levels_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_hierpartition.fn

@@ -0,0 +1,188 @@
+
+function Zf90_Set_Hier_Part_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Part_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, level, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: level
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Part_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_HIER_PART_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Hier_Part_Fn0f
+
+
+function Zf90_Set_Hier_Part_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Part_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,level,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: level
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Part_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_HIER_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Part_Fn1f
+
+
+function Zf90_Set_Hier_Part_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Part_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,level,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: level
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Part_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_HIER_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Part_Fn2f
+
+
+function Zf90_Set_Hier_Part_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Part_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,level,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: level
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Part_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_HIER_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Part_Fn3f
+
+
+function Zf90_Set_Hier_Part_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Part_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,level,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: level
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Part_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_HIER_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Part_Fn4f
+
+
+function Zf90_Set_Hier_Part_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Part_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,level,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: level
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Part_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_HIER_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Part_Fn5f
+
+
+function Zf90_Set_Hier_Part_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Part_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,level,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: level
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Part_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_HIER_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Part_Fn6f
+
+
+function Zf90_Set_Hier_Part_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Hier_Part_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,level,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: level
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Hier_Part_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_HIER_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Hier_Part_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_hierpartition.if

@@ -0,0 +1,23 @@
+interface Zoltan_Set_Hier_Part_Fn
+   module procedure Zf90_Set_Hier_Part_Fn0f
+   module procedure Zf90_Set_Hier_Part_Fn1f
+   module procedure Zf90_Set_Hier_Part_Fn2f
+   module procedure Zf90_Set_Hier_Part_Fn3f
+   module procedure Zf90_Set_Hier_Part_Fn4f
+   module procedure Zf90_Set_Hier_Part_Fn5f
+   module procedure Zf90_Set_Hier_Part_Fn6f
+   module procedure Zf90_Set_Hier_Part_Fn7f
+end interface
+
+! Backward compatibility with v3.0
+interface Zoltan_Set_Hier_Partition_Fn
+   module procedure Zf90_Set_Hier_Part_Fn0f
+   module procedure Zf90_Set_Hier_Part_Fn1f
+   module procedure Zf90_Set_Hier_Part_Fn2f
+   module procedure Zf90_Set_Hier_Part_Fn3f
+   module procedure Zf90_Set_Hier_Part_Fn4f
+   module procedure Zf90_Set_Hier_Part_Fn5f
+   module procedure Zf90_Set_Hier_Part_Fn6f
+   module procedure Zf90_Set_Hier_Part_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_midmigrate.fn

@@ -0,0 +1,220 @@
+
+function Zf90_Set_Mid_Migrate_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Mid_Migrate_Fn0s
+
+
+function Zf90_Set_Mid_Migrate_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_Fn1s
+
+
+function Zf90_Set_Mid_Migrate_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_Fn2s
+
+
+function Zf90_Set_Mid_Migrate_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_Fn3s
+
+
+function Zf90_Set_Mid_Migrate_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_Fn4s
+
+
+function Zf90_Set_Mid_Migrate_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_Fn5s
+
+
+function Zf90_Set_Mid_Migrate_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_Fn6s
+
+
+function Zf90_Set_Mid_Migrate_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_midmigrate.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Mid_Migrate_Fn
+   module procedure Zf90_Set_Mid_Migrate_Fn0s
+   module procedure Zf90_Set_Mid_Migrate_Fn1s
+   module procedure Zf90_Set_Mid_Migrate_Fn2s
+   module procedure Zf90_Set_Mid_Migrate_Fn3s
+   module procedure Zf90_Set_Mid_Migrate_Fn4s
+   module procedure Zf90_Set_Mid_Migrate_Fn5s
+   module procedure Zf90_Set_Mid_Migrate_Fn6s
+   module procedure Zf90_Set_Mid_Migrate_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_midmigratepp.fn

@@ -0,0 +1,228 @@
+
+function Zf90_Set_Mid_Migrate_PP_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_PP_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_PP_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_PP_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Mid_Migrate_PP_Fn0s
+
+
+function Zf90_Set_Mid_Migrate_PP_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_PP_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_PP_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_PP_Fn1s
+
+
+function Zf90_Set_Mid_Migrate_PP_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_PP_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_PP_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_PP_Fn2s
+
+
+function Zf90_Set_Mid_Migrate_PP_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_PP_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_PP_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_PP_Fn3s
+
+
+function Zf90_Set_Mid_Migrate_PP_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_PP_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_PP_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_PP_Fn4s
+
+
+function Zf90_Set_Mid_Migrate_PP_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_PP_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_PP_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_PP_Fn5s
+
+
+function Zf90_Set_Mid_Migrate_PP_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_PP_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_PP_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_PP_Fn6s
+
+
+function Zf90_Set_Mid_Migrate_PP_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Mid_Migrate_PP_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Mid_Migrate_PP_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_MID_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Mid_Migrate_PP_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_midmigratepp.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Mid_Migrate_PP_Fn
+   module procedure Zf90_Set_Mid_Migrate_PP_Fn0s
+   module procedure Zf90_Set_Mid_Migrate_PP_Fn1s
+   module procedure Zf90_Set_Mid_Migrate_PP_Fn2s
+   module procedure Zf90_Set_Mid_Migrate_PP_Fn3s
+   module procedure Zf90_Set_Mid_Migrate_PP_Fn4s
+   module procedure Zf90_Set_Mid_Migrate_PP_Fn5s
+   module procedure Zf90_Set_Mid_Migrate_PP_Fn6s
+   module procedure Zf90_Set_Mid_Migrate_PP_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_nextborderobj.fn

@@ -0,0 +1,252 @@
+
+function Zf90_Set_Next_Border_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Next_Border_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Border_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NEXT_BORDER_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Next_Border_Obj_Fn0f
+
+
+function Zf90_Set_Next_Border_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Border_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Border_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NEXT_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Border_Obj_Fn1f
+
+
+function Zf90_Set_Next_Border_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Border_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Border_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NEXT_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Border_Obj_Fn2f
+
+
+function Zf90_Set_Next_Border_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Border_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Border_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NEXT_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Border_Obj_Fn3f
+
+
+function Zf90_Set_Next_Border_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Border_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Border_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NEXT_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Border_Obj_Fn4f
+
+
+function Zf90_Set_Next_Border_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Border_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Border_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NEXT_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Border_Obj_Fn5f
+
+
+function Zf90_Set_Next_Border_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Border_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Border_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NEXT_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Border_Obj_Fn6f
+
+
+function Zf90_Set_Next_Border_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Border_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, nbor_proc, &
+    global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Border_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NEXT_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Border_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_nextborderobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Next_Border_Obj_Fn
+   module procedure Zf90_Set_Next_Border_Obj_Fn0f
+   module procedure Zf90_Set_Next_Border_Obj_Fn1f
+   module procedure Zf90_Set_Next_Border_Obj_Fn2f
+   module procedure Zf90_Set_Next_Border_Obj_Fn3f
+   module procedure Zf90_Set_Next_Border_Obj_Fn4f
+   module procedure Zf90_Set_Next_Border_Obj_Fn5f
+   module procedure Zf90_Set_Next_Border_Obj_Fn6f
+   module procedure Zf90_Set_Next_Border_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_nextcoarseobj.fn

@@ -0,0 +1,244 @@
+
+function Zf90_Set_Next_Coarse_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Next_Coarse_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    assigned, num_vert, vertices, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Coarse_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NEXT_COARSE_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Next_Coarse_Obj_Fn0f
+
+
+function Zf90_Set_Next_Coarse_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Coarse_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    assigned, num_vert, vertices, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert 
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Coarse_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NEXT_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Coarse_Obj_Fn1f
+
+
+function Zf90_Set_Next_Coarse_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Coarse_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    assigned, num_vert, vertices, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Coarse_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NEXT_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Coarse_Obj_Fn2f
+
+
+function Zf90_Set_Next_Coarse_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Coarse_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    assigned, num_vert, vertices, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Coarse_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NEXT_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Coarse_Obj_Fn3f
+
+
+function Zf90_Set_Next_Coarse_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Coarse_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    assigned, num_vert, vertices, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Coarse_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NEXT_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Coarse_Obj_Fn4f
+
+
+function Zf90_Set_Next_Coarse_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Coarse_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    assigned, num_vert, vertices, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Coarse_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NEXT_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Coarse_Obj_Fn5f
+
+
+function Zf90_Set_Next_Coarse_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Coarse_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    assigned, num_vert, vertices, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Coarse_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NEXT_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Coarse_Obj_Fn6f
+
+
+function Zf90_Set_Next_Coarse_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Coarse_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    assigned, num_vert, vertices, in_vertex, out_vertex, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(out) :: assigned, num_vert
+  integer(Zoltan_INT), intent(out) :: in_vertex, out_vertex
+  integer(Zoltan_INT), intent(out) :: vertices(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Coarse_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NEXT_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Coarse_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_nextcoarseobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Next_Coarse_Obj_Fn
+   module procedure Zf90_Set_Next_Coarse_Obj_Fn0f
+   module procedure Zf90_Set_Next_Coarse_Obj_Fn1f
+   module procedure Zf90_Set_Next_Coarse_Obj_Fn2f
+   module procedure Zf90_Set_Next_Coarse_Obj_Fn3f
+   module procedure Zf90_Set_Next_Coarse_Obj_Fn4f
+   module procedure Zf90_Set_Next_Coarse_Obj_Fn5f
+   module procedure Zf90_Set_Next_Coarse_Obj_Fn6f
+   module procedure Zf90_Set_Next_Coarse_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_nextobj.fn

@@ -0,0 +1,236 @@
+
+function Zf90_Set_Next_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Next_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NEXT_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Next_Obj_Fn0f
+
+
+function Zf90_Set_Next_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NEXT_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Obj_Fn1f
+
+
+function Zf90_Set_Next_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NEXT_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Obj_Fn2f
+
+
+function Zf90_Set_Next_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NEXT_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Obj_Fn3f
+
+
+function Zf90_Set_Next_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NEXT_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Obj_Fn4f
+
+
+function Zf90_Set_Next_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NEXT_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Obj_Fn5f
+
+
+function Zf90_Set_Next_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NEXT_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Obj_Fn6f
+
+
+function Zf90_Set_Next_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Next_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    next_global_id, next_local_id, &
+    wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: next_global_id(*), next_local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Next_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NEXT_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Next_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_nextobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Next_Obj_Fn
+   module procedure Zf90_Set_Next_Obj_Fn0f
+   module procedure Zf90_Set_Next_Obj_Fn1f
+   module procedure Zf90_Set_Next_Obj_Fn2f
+   module procedure Zf90_Set_Next_Obj_Fn3f
+   module procedure Zf90_Set_Next_Obj_Fn4f
+   module procedure Zf90_Set_Next_Obj_Fn5f
+   module procedure Zf90_Set_Next_Obj_Fn6f
+   module procedure Zf90_Set_Next_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_numborderobj.fn

@@ -0,0 +1,188 @@
+
+function Zf90_Set_Num_Border_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Num_Border_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, nbor_proc, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Border_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NUM_BORDER_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Num_Border_Obj_Fn0f
+
+
+function Zf90_Set_Num_Border_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Border_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,nbor_proc, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Border_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NUM_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Border_Obj_Fn1f
+
+
+function Zf90_Set_Num_Border_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Border_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,nbor_proc, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Border_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NUM_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Border_Obj_Fn2f
+
+
+function Zf90_Set_Num_Border_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Border_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,nbor_proc, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Border_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NUM_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Border_Obj_Fn3f
+
+
+function Zf90_Set_Num_Border_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Border_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,nbor_proc, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Border_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NUM_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Border_Obj_Fn4f
+
+
+function Zf90_Set_Num_Border_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Border_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,nbor_proc, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Border_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NUM_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Border_Obj_Fn5f
+
+
+function Zf90_Set_Num_Border_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Border_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,nbor_proc, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Border_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NUM_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Border_Obj_Fn6f
+
+
+function Zf90_Set_Num_Border_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Border_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,nbor_proc, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: nbor_proc
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Border_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NUM_BORDER_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Border_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_numborderobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Num_Border_Obj_Fn
+   module procedure Zf90_Set_Num_Border_Obj_Fn0f
+   module procedure Zf90_Set_Num_Border_Obj_Fn1f
+   module procedure Zf90_Set_Num_Border_Obj_Fn2f
+   module procedure Zf90_Set_Num_Border_Obj_Fn3f
+   module procedure Zf90_Set_Num_Border_Obj_Fn4f
+   module procedure Zf90_Set_Num_Border_Obj_Fn5f
+   module procedure Zf90_Set_Num_Border_Obj_Fn6f
+   module procedure Zf90_Set_Num_Border_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_numchild.fn

@@ -0,0 +1,203 @@
+
+function Zf90_Set_Num_Child_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Num_Child_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, local_id, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Child_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NUM_CHILD_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Num_Child_Fn0f
+
+
+function Zf90_Set_Num_Child_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Child_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Child_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NUM_CHILD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Child_Fn1f
+
+
+function Zf90_Set_Num_Child_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Child_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Child_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NUM_CHILD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Child_Fn2f
+
+
+function Zf90_Set_Num_Child_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Child_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Child_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NUM_CHILD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Child_Fn3f
+
+
+function Zf90_Set_Num_Child_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Child_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Child_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NUM_CHILD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Child_Fn4f
+
+
+function Zf90_Set_Num_Child_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Child_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Child_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NUM_CHILD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Child_Fn5f
+
+
+function Zf90_Set_Num_Child_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Child_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Child_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NUM_CHILD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Child_Fn6f
+
+
+function Zf90_Set_Num_Child_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Child_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Child_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NUM_CHILD_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Child_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_numchild.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Num_Child_Fn
+   module procedure Zf90_Set_Num_Child_Fn0f
+   module procedure Zf90_Set_Num_Child_Fn1f
+   module procedure Zf90_Set_Num_Child_Fn2f
+   module procedure Zf90_Set_Num_Child_Fn3f
+   module procedure Zf90_Set_Num_Child_Fn4f
+   module procedure Zf90_Set_Num_Child_Fn5f
+   module procedure Zf90_Set_Num_Child_Fn6f
+   module procedure Zf90_Set_Num_Child_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_numcoarseobj.fn

@@ -0,0 +1,180 @@
+
+function Zf90_Set_Num_Coarse_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Num_Coarse_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Coarse_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NUM_COARSE_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Num_Coarse_Obj_Fn0f
+
+
+function Zf90_Set_Num_Coarse_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Coarse_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Coarse_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NUM_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Coarse_Obj_Fn1f
+
+
+function Zf90_Set_Num_Coarse_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Coarse_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Coarse_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NUM_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Coarse_Obj_Fn2f
+
+
+function Zf90_Set_Num_Coarse_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Coarse_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Coarse_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NUM_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Coarse_Obj_Fn3f
+
+
+function Zf90_Set_Num_Coarse_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Coarse_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Coarse_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NUM_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Coarse_Obj_Fn4f
+
+
+function Zf90_Set_Num_Coarse_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Coarse_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Coarse_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NUM_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Coarse_Obj_Fn5f
+
+
+function Zf90_Set_Num_Coarse_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Coarse_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Coarse_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NUM_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Coarse_Obj_Fn6f
+
+
+function Zf90_Set_Num_Coarse_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Coarse_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Coarse_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NUM_COARSE_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Coarse_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_numcoarseobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Num_Coarse_Obj_Fn
+   module procedure Zf90_Set_Num_Coarse_Obj_Fn0f
+   module procedure Zf90_Set_Num_Coarse_Obj_Fn1f
+   module procedure Zf90_Set_Num_Coarse_Obj_Fn2f
+   module procedure Zf90_Set_Num_Coarse_Obj_Fn3f
+   module procedure Zf90_Set_Num_Coarse_Obj_Fn4f
+   module procedure Zf90_Set_Num_Coarse_Obj_Fn5f
+   module procedure Zf90_Set_Num_Coarse_Obj_Fn6f
+   module procedure Zf90_Set_Num_Coarse_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_numedges.fn

@@ -0,0 +1,203 @@
+
+function Zf90_Set_Num_Edges_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, local_id, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NUM_EDGES_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Num_Edges_Fn0f
+
+
+function Zf90_Set_Num_Edges_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NUM_EDGES_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Fn1f
+
+
+function Zf90_Set_Num_Edges_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NUM_EDGES_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Fn2f
+
+
+function Zf90_Set_Num_Edges_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NUM_EDGES_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Fn3f
+
+
+function Zf90_Set_Num_Edges_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NUM_EDGES_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Fn4f
+
+
+function Zf90_Set_Num_Edges_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NUM_EDGES_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Fn5f
+
+
+function Zf90_Set_Num_Edges_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NUM_EDGES_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Fn6f
+
+
+function Zf90_Set_Num_Edges_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NUM_EDGES_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_numedges.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Num_Edges_Fn
+   module procedure Zf90_Set_Num_Edges_Fn0f
+   module procedure Zf90_Set_Num_Edges_Fn1f
+   module procedure Zf90_Set_Num_Edges_Fn2f
+   module procedure Zf90_Set_Num_Edges_Fn3f
+   module procedure Zf90_Set_Num_Edges_Fn4f
+   module procedure Zf90_Set_Num_Edges_Fn5f
+   module procedure Zf90_Set_Num_Edges_Fn6f
+   module procedure Zf90_Set_Num_Edges_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_numedgesmulti.fn

@@ -0,0 +1,212 @@
+
+function Zf90_Set_Num_Edges_Multi_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Multi_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_edges, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj 
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_edges(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Multi_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_NUM_EDGES_MULTI_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Num_Edges_Multi_Fn0s
+
+
+function Zf90_Set_Num_Edges_Multi_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Multi_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_edges, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj 
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_edges(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Multi_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_NUM_EDGES_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Multi_Fn1s
+
+
+function Zf90_Set_Num_Edges_Multi_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Multi_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_edges, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj 
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_edges(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Multi_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_NUM_EDGES_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Multi_Fn2s
+
+
+function Zf90_Set_Num_Edges_Multi_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Multi_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_edges, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj 
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_edges(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Multi_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_NUM_EDGES_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Multi_Fn3s
+
+
+function Zf90_Set_Num_Edges_Multi_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Multi_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_edges, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj 
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_edges(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Multi_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_NUM_EDGES_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Multi_Fn4s
+
+
+function Zf90_Set_Num_Edges_Multi_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Multi_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_edges, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj 
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_edges(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Multi_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_NUM_EDGES_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Multi_Fn5s
+
+
+function Zf90_Set_Num_Edges_Multi_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Multi_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_edges, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj 
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_edges(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Multi_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_NUM_EDGES_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Multi_Fn6s
+
+
+function Zf90_Set_Num_Edges_Multi_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Edges_Multi_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, &
+    global_id, local_id, num_edges, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: num_obj 
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_edges(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Edges_Multi_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_NUM_EDGES_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Edges_Multi_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_numedgesmulti.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Num_Edges_Multi_Fn
+   module procedure Zf90_Set_Num_Edges_Multi_Fn0s
+   module procedure Zf90_Set_Num_Edges_Multi_Fn1s
+   module procedure Zf90_Set_Num_Edges_Multi_Fn2s
+   module procedure Zf90_Set_Num_Edges_Multi_Fn3s
+   module procedure Zf90_Set_Num_Edges_Multi_Fn4s
+   module procedure Zf90_Set_Num_Edges_Multi_Fn5s
+   module procedure Zf90_Set_Num_Edges_Multi_Fn6s
+   module procedure Zf90_Set_Num_Edges_Multi_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_numfixedobj.fn

@@ -0,0 +1,180 @@
+
+function Zf90_Set_Num_Fixed_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Num_Fixed_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy,  ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Fixed_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NUM_FIXED_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Num_Fixed_Obj_Fn0f
+
+
+function Zf90_Set_Num_Fixed_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Fixed_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Fixed_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NUM_FIXED_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Fixed_Obj_Fn1f
+
+
+function Zf90_Set_Num_Fixed_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Fixed_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Fixed_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NUM_FIXED_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Fixed_Obj_Fn2f
+
+
+function Zf90_Set_Num_Fixed_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Fixed_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,  ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Fixed_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NUM_FIXED_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Fixed_Obj_Fn3f
+
+
+function Zf90_Set_Num_Fixed_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Fixed_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Fixed_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NUM_FIXED_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Fixed_Obj_Fn4f
+
+
+function Zf90_Set_Num_Fixed_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Fixed_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Fixed_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NUM_FIXED_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Fixed_Obj_Fn5f
+
+
+function Zf90_Set_Num_Fixed_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Fixed_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Fixed_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NUM_FIXED_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Fixed_Obj_Fn6f
+
+
+function Zf90_Set_Num_Fixed_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Fixed_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Fixed_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NUM_FIXED_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Fixed_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_numfixedobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Num_Fixed_Obj_Fn
+   module procedure Zf90_Set_Num_Fixed_Obj_Fn0f
+   module procedure Zf90_Set_Num_Fixed_Obj_Fn1f
+   module procedure Zf90_Set_Num_Fixed_Obj_Fn2f
+   module procedure Zf90_Set_Num_Fixed_Obj_Fn3f
+   module procedure Zf90_Set_Num_Fixed_Obj_Fn4f
+   module procedure Zf90_Set_Num_Fixed_Obj_Fn5f
+   module procedure Zf90_Set_Num_Fixed_Obj_Fn6f
+   module procedure Zf90_Set_Num_Fixed_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_numgeom.fn

@@ -0,0 +1,180 @@
+
+function Zf90_Set_Num_Geom_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Num_Geom_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Geom_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NUM_GEOM_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Num_Geom_Fn0f
+
+
+function Zf90_Set_Num_Geom_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Geom_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Geom_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NUM_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Geom_Fn1f
+
+
+function Zf90_Set_Num_Geom_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Geom_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Geom_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NUM_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Geom_Fn2f
+
+
+function Zf90_Set_Num_Geom_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Geom_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Geom_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NUM_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Geom_Fn3f
+
+
+function Zf90_Set_Num_Geom_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Geom_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Geom_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NUM_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Geom_Fn4f
+
+
+function Zf90_Set_Num_Geom_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Geom_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Geom_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NUM_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Geom_Fn5f
+
+
+function Zf90_Set_Num_Geom_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Geom_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Geom_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NUM_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Geom_Fn6f
+
+
+function Zf90_Set_Num_Geom_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Geom_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Geom_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NUM_GEOM_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Geom_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_numgeom.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Num_Geom_Fn
+   module procedure Zf90_Set_Num_Geom_Fn0f
+   module procedure Zf90_Set_Num_Geom_Fn1f
+   module procedure Zf90_Set_Num_Geom_Fn2f
+   module procedure Zf90_Set_Num_Geom_Fn3f
+   module procedure Zf90_Set_Num_Geom_Fn4f
+   module procedure Zf90_Set_Num_Geom_Fn5f
+   module procedure Zf90_Set_Num_Geom_Fn6f
+   module procedure Zf90_Set_Num_Geom_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_numobj.fn

@@ -0,0 +1,180 @@
+
+function Zf90_Set_Num_Obj_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Num_Obj_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Obj_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_NUM_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Num_Obj_Fn0f
+
+
+function Zf90_Set_Num_Obj_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Obj_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Obj_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_NUM_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Obj_Fn1f
+
+
+function Zf90_Set_Num_Obj_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Obj_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Obj_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_NUM_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Obj_Fn2f
+
+
+function Zf90_Set_Num_Obj_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Obj_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Obj_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_NUM_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Obj_Fn3f
+
+
+function Zf90_Set_Num_Obj_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Obj_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Obj_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_NUM_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Obj_Fn4f
+
+
+function Zf90_Set_Num_Obj_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Obj_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Obj_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_NUM_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Obj_Fn5f
+
+
+function Zf90_Set_Num_Obj_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Obj_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Obj_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_NUM_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Obj_Fn6f
+
+
+function Zf90_Set_Num_Obj_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Num_Obj_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data,ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Num_Obj_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_NUM_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Num_Obj_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_numobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Num_Obj_Fn
+   module procedure Zf90_Set_Num_Obj_Fn0f
+   module procedure Zf90_Set_Num_Obj_Fn1f
+   module procedure Zf90_Set_Num_Obj_Fn2f
+   module procedure Zf90_Set_Num_Obj_Fn3f
+   module procedure Zf90_Set_Num_Obj_Fn4f
+   module procedure Zf90_Set_Num_Obj_Fn5f
+   module procedure Zf90_Set_Num_Obj_Fn6f
+   module procedure Zf90_Set_Num_Obj_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_objlist.fn

@@ -0,0 +1,212 @@
+
+function Zf90_Set_Obj_List_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Obj_List_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_List_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_OBJ_LIST_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Obj_List_Fn0s
+
+
+function Zf90_Set_Obj_List_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_List_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_List_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_List_Fn1s
+
+
+function Zf90_Set_Obj_List_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_List_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_List_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_List_Fn2s
+
+
+function Zf90_Set_Obj_List_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_List_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_List_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_List_Fn3s
+
+
+function Zf90_Set_Obj_List_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_List_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_List_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_List_Fn4s
+
+
+function Zf90_Set_Obj_List_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_List_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_List_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_List_Fn5s
+
+
+function Zf90_Set_Obj_List_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_List_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_List_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_List_Fn6s
+
+
+function Zf90_Set_Obj_List_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_List_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, wdim, objwgts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(out) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in)  :: wdim
+  real(Zoltan_FLOAT),  intent(out) :: objwgts(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_List_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_OBJ_LIST_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_List_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_objlist.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Obj_List_Fn
+   module procedure Zf90_Set_Obj_List_Fn0s
+   module procedure Zf90_Set_Obj_List_Fn1s
+   module procedure Zf90_Set_Obj_List_Fn2s
+   module procedure Zf90_Set_Obj_List_Fn3s
+   module procedure Zf90_Set_Obj_List_Fn4s
+   module procedure Zf90_Set_Obj_List_Fn5s
+   module procedure Zf90_Set_Obj_List_Fn6s
+   module procedure Zf90_Set_Obj_List_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_objsize.fn

@@ -0,0 +1,203 @@
+
+function Zf90_Set_Obj_Size_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, local_id, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Obj_Size_Fn0f
+
+
+function Zf90_Set_Obj_Size_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Fn1f
+
+
+function Zf90_Set_Obj_Size_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Fn2f
+
+
+function Zf90_Set_Obj_Size_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Fn3f
+
+
+function Zf90_Set_Obj_Size_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Fn4f
+
+
+function Zf90_Set_Obj_Size_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Fn5f
+
+
+function Zf90_Set_Obj_Size_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Fn6f
+
+
+function Zf90_Set_Obj_Size_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_objsize.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Obj_Size_Fn
+   module procedure Zf90_Set_Obj_Size_Fn0f
+   module procedure Zf90_Set_Obj_Size_Fn1f
+   module procedure Zf90_Set_Obj_Size_Fn2f
+   module procedure Zf90_Set_Obj_Size_Fn3f
+   module procedure Zf90_Set_Obj_Size_Fn4f
+   module procedure Zf90_Set_Obj_Size_Fn5f
+   module procedure Zf90_Set_Obj_Size_Fn6f
+   module procedure Zf90_Set_Obj_Size_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_objsizemulti.fn

@@ -0,0 +1,204 @@
+
+function Zf90_Set_Obj_Size_Multi_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Multi_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, num_bytes, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_bytes(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Multi_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_MULTI_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Obj_Size_Multi_Fn0s
+
+
+function Zf90_Set_Obj_Size_Multi_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Multi_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, num_bytes, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_bytes(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Multi_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Multi_Fn1s
+
+
+function Zf90_Set_Obj_Size_Multi_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Multi_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, num_bytes, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_bytes(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Multi_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Multi_Fn2s
+
+
+function Zf90_Set_Obj_Size_Multi_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Multi_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, num_bytes, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_bytes(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Multi_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Multi_Fn3s
+
+
+function Zf90_Set_Obj_Size_Multi_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Multi_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, num_bytes, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_bytes(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Multi_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Multi_Fn4s
+
+
+function Zf90_Set_Obj_Size_Multi_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Multi_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, num_bytes, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_bytes(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Multi_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Multi_Fn5s
+
+
+function Zf90_Set_Obj_Size_Multi_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Multi_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, num_bytes, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_bytes(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Multi_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Multi_Fn6s
+
+
+function Zf90_Set_Obj_Size_Multi_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Obj_Size_Multi_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, num_bytes, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: num_bytes(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Obj_Size_Multi_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_OBJ_SIZE_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Obj_Size_Multi_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_objsizemulti.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Obj_Size_Multi_Fn
+   module procedure Zf90_Set_Obj_Size_Multi_Fn0s
+   module procedure Zf90_Set_Obj_Size_Multi_Fn1s
+   module procedure Zf90_Set_Obj_Size_Multi_Fn2s
+   module procedure Zf90_Set_Obj_Size_Multi_Fn3s
+   module procedure Zf90_Set_Obj_Size_Multi_Fn4s
+   module procedure Zf90_Set_Obj_Size_Multi_Fn5s
+   module procedure Zf90_Set_Obj_Size_Multi_Fn6s
+   module procedure Zf90_Set_Obj_Size_Multi_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_packobj.fn

@@ -0,0 +1,212 @@
+
+function Zf90_Set_Pack_Obj_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, &
+    local_id, dest_proc, size, buf, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc, size
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Pack_Obj_Fn0s
+
+
+function Zf90_Set_Pack_Obj_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, dest_proc, size, buf, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc, size
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Fn1s
+
+
+function Zf90_Set_Pack_Obj_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, dest_proc, size, buf, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc, size
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Fn2s
+
+
+function Zf90_Set_Pack_Obj_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, dest_proc, size, buf, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc, size
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Fn3s
+
+
+function Zf90_Set_Pack_Obj_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, dest_proc, size, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc, size
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Fn4s
+
+
+function Zf90_Set_Pack_Obj_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, dest_proc, size, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc, size
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Fn5s
+
+
+function Zf90_Set_Pack_Obj_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, dest_proc, size, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc, size
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Fn6s
+
+
+function Zf90_Set_Pack_Obj_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, global_id, &
+    local_id, dest_proc, size, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc, size
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_packobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Pack_Obj_Fn
+   module procedure Zf90_Set_Pack_Obj_Fn0s
+   module procedure Zf90_Set_Pack_Obj_Fn1s
+   module procedure Zf90_Set_Pack_Obj_Fn2s
+   module procedure Zf90_Set_Pack_Obj_Fn3s
+   module procedure Zf90_Set_Pack_Obj_Fn4s
+   module procedure Zf90_Set_Pack_Obj_Fn5s
+   module procedure Zf90_Set_Pack_Obj_Fn6s
+   module procedure Zf90_Set_Pack_Obj_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_packobjmulti.fn

@@ -0,0 +1,212 @@
+
+function Zf90_Set_Pack_Obj_Multi_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Multi_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, dest_proc, size, idx, buf, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc(*), size(*), idx(*)
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Multi_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Pack_Obj_Multi_Fn0s
+
+
+function Zf90_Set_Pack_Obj_Multi_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Multi_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, dest_proc, size, idx, buf, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc(*), size(*), idx(*)
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Multi_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Multi_Fn1s
+
+
+function Zf90_Set_Pack_Obj_Multi_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Multi_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, dest_proc, size, idx, buf, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc(*), size(*), idx(*)
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Multi_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Multi_Fn2s
+
+
+function Zf90_Set_Pack_Obj_Multi_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Multi_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, dest_proc, size, idx, buf, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc(*), size(*), idx(*)
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Multi_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Multi_Fn3s
+
+
+function Zf90_Set_Pack_Obj_Multi_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Multi_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, dest_proc, size, idx, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc(*), size(*), idx(*)
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Multi_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Multi_Fn4s
+
+
+function Zf90_Set_Pack_Obj_Multi_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Multi_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, dest_proc, size, idx, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc(*), size(*), idx(*)
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Multi_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Multi_Fn5s
+
+
+function Zf90_Set_Pack_Obj_Multi_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Multi_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, dest_proc, size, idx, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc(*), size(*), idx(*)
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Multi_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Multi_Fn6s
+
+
+function Zf90_Set_Pack_Obj_Multi_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pack_Obj_Multi_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_ids, &
+    global_id, local_id, dest_proc, size, idx, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_lid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(in) :: dest_proc(*), size(*), idx(*)
+  integer(Zoltan_INT), intent(out) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pack_Obj_Multi_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_PACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pack_Obj_Multi_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_packobjmulti.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Pack_Obj_Multi_Fn
+   module procedure Zf90_Set_Pack_Obj_Multi_Fn0s
+   module procedure Zf90_Set_Pack_Obj_Multi_Fn1s
+   module procedure Zf90_Set_Pack_Obj_Multi_Fn2s
+   module procedure Zf90_Set_Pack_Obj_Multi_Fn3s
+   module procedure Zf90_Set_Pack_Obj_Multi_Fn4s
+   module procedure Zf90_Set_Pack_Obj_Multi_Fn5s
+   module procedure Zf90_Set_Pack_Obj_Multi_Fn6s
+   module procedure Zf90_Set_Pack_Obj_Multi_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_partition.fn

@@ -0,0 +1,203 @@
+
+function Zf90_Set_Part_Fn0f(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Part_Fn0f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(dummy, num_gid_entries, num_lid_entries, global_id, local_id, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Fn0f = Zfw_Set_Fn0f(zz_addr,nbytes,ZOLTAN_PART_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Part_Fn0f
+
+
+function Zf90_Set_Part_Fn1f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Fn1f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Fn1f = Zfw_Set_Fn1f(zz_addr,nbytes,ZOLTAN_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Fn1f
+
+
+function Zf90_Set_Part_Fn2f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Fn2f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Fn2f = Zfw_Set_Fn2f(zz_addr,nbytes,ZOLTAN_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Fn2f
+
+
+function Zf90_Set_Part_Fn3f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Fn3f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  integer(Zoltan_INT) :: fn_ptr
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Fn3f = Zfw_Set_Fn3f(zz_addr,nbytes,ZOLTAN_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Fn3f
+
+
+function Zf90_Set_Part_Fn4f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Fn4f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Fn4f = Zfw_Set_Fn4f(zz_addr,nbytes,ZOLTAN_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Fn4f
+
+
+function Zf90_Set_Part_Fn5f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Fn5f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Fn5f = Zfw_Set_Fn5f(zz_addr,nbytes,ZOLTAN_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Fn5f
+
+
+function Zf90_Set_Part_Fn6f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Fn6f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Fn6f = Zfw_Set_Fn6f(zz_addr,nbytes,ZOLTAN_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Fn6f
+
+
+function Zf90_Set_Part_Fn7f(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Fn7f
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  function fn_ptr(data, num_gid_entries, num_lid_entries, global_id, local_id, &
+    ierr)
+  use zoltan_types
+  use zoltan_user_data
+  integer(Zoltan_INT) :: fn_ptr
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end function fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Fn7f = Zfw_Set_Fn7f(zz_addr,nbytes,ZOLTAN_PART_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Fn7f
+
+

thirdParty/Zoltan/src/fort/set_partition.if

@@ -0,0 +1,23 @@
+interface Zoltan_Set_Part_Fn
+   module procedure Zf90_Set_Part_Fn0f
+   module procedure Zf90_Set_Part_Fn1f
+   module procedure Zf90_Set_Part_Fn2f
+   module procedure Zf90_Set_Part_Fn3f
+   module procedure Zf90_Set_Part_Fn4f
+   module procedure Zf90_Set_Part_Fn5f
+   module procedure Zf90_Set_Part_Fn6f
+   module procedure Zf90_Set_Part_Fn7f
+end interface
+
+! Backward compatibility with v3.0
+interface Zoltan_Set_Partition_Fn
+   module procedure Zf90_Set_Part_Fn0f
+   module procedure Zf90_Set_Part_Fn1f
+   module procedure Zf90_Set_Part_Fn2f
+   module procedure Zf90_Set_Part_Fn3f
+   module procedure Zf90_Set_Part_Fn4f
+   module procedure Zf90_Set_Part_Fn5f
+   module procedure Zf90_Set_Part_Fn6f
+   module procedure Zf90_Set_Part_Fn7f
+end interface
+

thirdParty/Zoltan/src/fort/set_partitionmulti.fn

@@ -0,0 +1,195 @@
+
+function Zf90_Set_Part_Multi_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Part_Multi_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, num_obj, global_id, local_id, parts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: parts(*), ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Multi_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_PART_MULTI_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Part_Multi_Fn0s
+
+
+function Zf90_Set_Part_Multi_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Multi_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, global_id, local_id, &
+    parts, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: parts(*), ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Multi_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_PART_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Multi_Fn1s
+
+
+function Zf90_Set_Part_Multi_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Multi_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, global_id, local_id, &
+    parts, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: parts(*), ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Multi_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_PART_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Multi_Fn2s
+
+
+function Zf90_Set_Part_Multi_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Multi_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, global_id, local_id, &
+    parts, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: parts(*), ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Multi_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_PART_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Multi_Fn3s
+
+
+function Zf90_Set_Part_Multi_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Multi_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, global_id, local_id, &
+    parts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: parts(*), ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Multi_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_PART_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Multi_Fn4s
+
+
+function Zf90_Set_Part_Multi_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Multi_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, global_id, local_id, &
+    parts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: parts(*), ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Multi_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_PART_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Multi_Fn5s
+
+
+function Zf90_Set_Part_Multi_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Multi_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, global_id, local_id, &
+    parts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: parts(*), ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Multi_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_PART_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Multi_Fn6s
+
+
+function Zf90_Set_Part_Multi_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Part_Multi_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, num_obj, global_id, local_id, &
+    parts, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries, num_obj
+  integer(Zoltan_INT), intent(in)  :: global_id(*), local_id(*)
+  integer(Zoltan_INT), intent(out) :: parts(*), ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Part_Multi_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_PART_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Part_Multi_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_partitionmulti.if

@@ -0,0 +1,23 @@
+interface Zoltan_Set_Part_Multi_Fn
+   module procedure Zf90_Set_Part_Multi_Fn0s
+   module procedure Zf90_Set_Part_Multi_Fn1s
+   module procedure Zf90_Set_Part_Multi_Fn2s
+   module procedure Zf90_Set_Part_Multi_Fn3s
+   module procedure Zf90_Set_Part_Multi_Fn4s
+   module procedure Zf90_Set_Part_Multi_Fn5s
+   module procedure Zf90_Set_Part_Multi_Fn6s
+   module procedure Zf90_Set_Part_Multi_Fn7s
+end interface
+
+! Backward compatibility with v3.0
+interface Zoltan_Set_Partition_Multi_Fn
+   module procedure Zf90_Set_Part_Multi_Fn0s
+   module procedure Zf90_Set_Part_Multi_Fn1s
+   module procedure Zf90_Set_Part_Multi_Fn2s
+   module procedure Zf90_Set_Part_Multi_Fn3s
+   module procedure Zf90_Set_Part_Multi_Fn4s
+   module procedure Zf90_Set_Part_Multi_Fn5s
+   module procedure Zf90_Set_Part_Multi_Fn6s
+   module procedure Zf90_Set_Part_Multi_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_postmigrate.fn

@@ -0,0 +1,220 @@
+
+function Zf90_Set_Post_Migrate_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Post_Migrate_Fn0s
+
+
+function Zf90_Set_Post_Migrate_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_Fn1s
+
+
+function Zf90_Set_Post_Migrate_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_Fn2s
+
+
+function Zf90_Set_Post_Migrate_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_Fn3s
+
+
+function Zf90_Set_Post_Migrate_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_Fn4s
+
+
+function Zf90_Set_Post_Migrate_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_Fn5s
+
+
+function Zf90_Set_Post_Migrate_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_Fn6s
+
+
+function Zf90_Set_Post_Migrate_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_postmigrate.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Post_Migrate_Fn
+   module procedure Zf90_Set_Post_Migrate_Fn0s
+   module procedure Zf90_Set_Post_Migrate_Fn1s
+   module procedure Zf90_Set_Post_Migrate_Fn2s
+   module procedure Zf90_Set_Post_Migrate_Fn3s
+   module procedure Zf90_Set_Post_Migrate_Fn4s
+   module procedure Zf90_Set_Post_Migrate_Fn5s
+   module procedure Zf90_Set_Post_Migrate_Fn6s
+   module procedure Zf90_Set_Post_Migrate_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_postmigratepp.fn

@@ -0,0 +1,228 @@
+
+function Zf90_Set_Post_Migrate_PP_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_PP_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_PP_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_PP_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Post_Migrate_PP_Fn0s
+
+
+function Zf90_Set_Post_Migrate_PP_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_PP_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_PP_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_PP_Fn1s
+
+
+function Zf90_Set_Post_Migrate_PP_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_PP_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_PP_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_PP_Fn2s
+
+
+function Zf90_Set_Post_Migrate_PP_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_PP_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_PP_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_PP_Fn3s
+
+
+function Zf90_Set_Post_Migrate_PP_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_PP_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_PP_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_PP_Fn4s
+
+
+function Zf90_Set_Post_Migrate_PP_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_PP_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_PP_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_PP_Fn5s
+
+
+function Zf90_Set_Post_Migrate_PP_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_PP_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_PP_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_PP_Fn6s
+
+
+function Zf90_Set_Post_Migrate_PP_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Post_Migrate_PP_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Post_Migrate_PP_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_POST_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Post_Migrate_PP_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_postmigratepp.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Post_Migrate_PP_Fn
+   module procedure Zf90_Set_Post_Migrate_PP_Fn0s
+   module procedure Zf90_Set_Post_Migrate_PP_Fn1s
+   module procedure Zf90_Set_Post_Migrate_PP_Fn2s
+   module procedure Zf90_Set_Post_Migrate_PP_Fn3s
+   module procedure Zf90_Set_Post_Migrate_PP_Fn4s
+   module procedure Zf90_Set_Post_Migrate_PP_Fn5s
+   module procedure Zf90_Set_Post_Migrate_PP_Fn6s
+   module procedure Zf90_Set_Post_Migrate_PP_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_premigrate.fn

@@ -0,0 +1,220 @@
+
+function Zf90_Set_Pre_Migrate_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Pre_Migrate_Fn0s
+
+
+function Zf90_Set_Pre_Migrate_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_Fn1s
+
+
+function Zf90_Set_Pre_Migrate_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_Fn2s
+
+
+function Zf90_Set_Pre_Migrate_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_Fn3s
+
+
+function Zf90_Set_Pre_Migrate_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_Fn4s
+
+
+function Zf90_Set_Pre_Migrate_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_Fn5s
+
+
+function Zf90_Set_Pre_Migrate_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_Fn6s
+
+
+function Zf90_Set_Pre_Migrate_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, &
+    num_export, exp_gids, exp_lids, exp_procs, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_premigrate.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Pre_Migrate_Fn
+   module procedure Zf90_Set_Pre_Migrate_Fn0s
+   module procedure Zf90_Set_Pre_Migrate_Fn1s
+   module procedure Zf90_Set_Pre_Migrate_Fn2s
+   module procedure Zf90_Set_Pre_Migrate_Fn3s
+   module procedure Zf90_Set_Pre_Migrate_Fn4s
+   module procedure Zf90_Set_Pre_Migrate_Fn5s
+   module procedure Zf90_Set_Pre_Migrate_Fn6s
+   module procedure Zf90_Set_Pre_Migrate_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_premigratepp.fn

@@ -0,0 +1,228 @@
+
+function Zf90_Set_Pre_Migrate_PP_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_PP_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_PP_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_PP_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Pre_Migrate_PP_Fn0s
+
+
+function Zf90_Set_Pre_Migrate_PP_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_PP_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_PP_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_PP_Fn1s
+
+
+function Zf90_Set_Pre_Migrate_PP_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_PP_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_PP_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_PP_Fn2s
+
+
+function Zf90_Set_Pre_Migrate_PP_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_PP_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_PP_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_PP_Fn3s
+
+
+function Zf90_Set_Pre_Migrate_PP_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_PP_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_PP_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_PP_Fn4s
+
+
+function Zf90_Set_Pre_Migrate_PP_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_PP_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_PP_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_PP_Fn5s
+
+
+function Zf90_Set_Pre_Migrate_PP_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_PP_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_PP_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_PP_Fn6s
+
+
+function Zf90_Set_Pre_Migrate_PP_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Pre_Migrate_PP_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_lid_entries, &
+    num_import, imp_gids, imp_lids, imp_procs, imp_to_part, &
+    num_export, exp_gids, exp_lids, exp_procs, exp_to_part, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in)  :: num_gid_entries, num_lid_entries
+  integer(Zoltan_INT), intent(in)  :: num_import, num_export
+  integer(Zoltan_INT), intent(in)  :: imp_gids(*), imp_lids(*), imp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: exp_gids(*), exp_lids(*), exp_procs(*)
+  integer(Zoltan_INT), intent(in)  :: imp_to_part(*), exp_to_part(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Pre_Migrate_PP_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_PRE_MIGRATE_PP_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Pre_Migrate_PP_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_premigratepp.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Pre_Migrate_PP_Fn
+   module procedure Zf90_Set_Pre_Migrate_PP_Fn0s
+   module procedure Zf90_Set_Pre_Migrate_PP_Fn1s
+   module procedure Zf90_Set_Pre_Migrate_PP_Fn2s
+   module procedure Zf90_Set_Pre_Migrate_PP_Fn3s
+   module procedure Zf90_Set_Pre_Migrate_PP_Fn4s
+   module procedure Zf90_Set_Pre_Migrate_PP_Fn5s
+   module procedure Zf90_Set_Pre_Migrate_PP_Fn6s
+   module procedure Zf90_Set_Pre_Migrate_PP_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_unpackobj.fn

@@ -0,0 +1,204 @@
+
+function Zf90_Set_Unpack_Obj_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, global_id, size, buf, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Unpack_Obj_Fn0s
+
+
+function Zf90_Set_Unpack_Obj_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, global_id, size, buf, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Fn1s
+
+
+function Zf90_Set_Unpack_Obj_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, global_id, size, buf, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Fn2s
+
+
+function Zf90_Set_Unpack_Obj_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, global_id, size, buf, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Fn3s
+
+
+function Zf90_Set_Unpack_Obj_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, global_id, size, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Fn4s
+
+
+function Zf90_Set_Unpack_Obj_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, global_id, size, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Fn5s
+
+
+function Zf90_Set_Unpack_Obj_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, global_id, size, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Fn6s
+
+
+function Zf90_Set_Unpack_Obj_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, global_id, size, buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_unpackobj.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Unpack_Obj_Fn
+   module procedure Zf90_Set_Unpack_Obj_Fn0s
+   module procedure Zf90_Set_Unpack_Obj_Fn1s
+   module procedure Zf90_Set_Unpack_Obj_Fn2s
+   module procedure Zf90_Set_Unpack_Obj_Fn3s
+   module procedure Zf90_Set_Unpack_Obj_Fn4s
+   module procedure Zf90_Set_Unpack_Obj_Fn5s
+   module procedure Zf90_Set_Unpack_Obj_Fn6s
+   module procedure Zf90_Set_Unpack_Obj_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/set_unpackobjmulti.fn

@@ -0,0 +1,212 @@
+
+function Zf90_Set_Unpack_Obj_Multi_Fn0s(zz,fn_ptr)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Multi_Fn0s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(dummy, num_gid_entries, num_ids, global_id, size, idx, &
+    buf, ierr)
+  use zoltan_types
+  integer(Zoltan_INT), intent(in)  :: dummy(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size(*), idx(*)
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Multi_Fn0s = Zfw_Set_Fn0s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr)
+end function Zf90_Set_Unpack_Obj_Multi_Fn0s
+
+
+function Zf90_Set_Unpack_Obj_Multi_Fn1s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Multi_Fn1s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_ids, global_id, size, idx, &
+    buf, ierr)
+  use zoltan_types
+  integer(Zoltan_INT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size(*), idx(*)
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+integer(Zoltan_INT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Multi_Fn1s = Zfw_Set_Fn1s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Multi_Fn1s
+
+
+function Zf90_Set_Unpack_Obj_Multi_Fn2s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Multi_Fn2s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_ids, global_id, size, idx, &
+    buf, ierr)
+  use zoltan_types
+  real(Zoltan_FLOAT) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size(*), idx(*)
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_FLOAT) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Multi_Fn2s = Zfw_Set_Fn2s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Multi_Fn2s
+
+
+function Zf90_Set_Unpack_Obj_Multi_Fn3s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Multi_Fn3s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_ids, global_id, size, idx, &
+    buf, ierr)
+  use zoltan_types
+  real(Zoltan_DOUBLE) , intent(in) :: data(*)
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size(*), idx(*)
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+real(Zoltan_DOUBLE) , intent(in) :: data(*)
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Multi_Fn3s = Zfw_Set_Fn3s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Multi_Fn3s
+
+
+function Zf90_Set_Unpack_Obj_Multi_Fn4s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Multi_Fn4s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_ids, global_id, size, idx, &
+    buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_1) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size(*), idx(*)
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_1) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Multi_Fn4s = Zfw_Set_Fn4s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Multi_Fn4s
+
+
+function Zf90_Set_Unpack_Obj_Multi_Fn5s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Multi_Fn5s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_ids, global_id, size, idx, &
+    buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_2) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size(*), idx(*)
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_2) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Multi_Fn5s = Zfw_Set_Fn5s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Multi_Fn5s
+
+
+function Zf90_Set_Unpack_Obj_Multi_Fn6s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Multi_Fn6s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_ids, global_id, size, idx, &
+    buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_3) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size(*), idx(*)
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_3) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Multi_Fn6s = Zfw_Set_Fn6s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Multi_Fn6s
+
+
+function Zf90_Set_Unpack_Obj_Multi_Fn7s(zz,fn_ptr,data)
+integer(Zoltan_INT) :: Zf90_Set_Unpack_Obj_Multi_Fn7s
+type(Zoltan_Struct) , intent(in) :: zz
+interface
+  subroutine fn_ptr(data, num_gid_entries, num_ids, global_id, size, idx, &
+    buf, ierr)
+  use zoltan_types
+  use zoltan_user_data
+  type(Zoltan_User_Data_4) , intent(in) :: data
+  integer(Zoltan_INT), intent(in) :: num_gid_entries, num_ids
+  integer(Zoltan_INT), intent(in) :: global_id(*)
+  integer(Zoltan_INT), intent(in) :: size(*), idx(*)
+  integer(Zoltan_INT), intent(in) :: buf(*)
+  integer(Zoltan_INT), intent(out) :: ierr
+  end subroutine fn_ptr
+end interface
+type(Zoltan_User_Data_4) , intent(in) :: data
+integer(Zoltan_INT), dimension(Zoltan_PTR_LENGTH) :: zz_addr
+integer(Zoltan_INT) :: nbytes, i
+nbytes = Zoltan_PTR_LENGTH
+do i=1,nbytes
+   zz_addr(i) = ichar(zz%addr%addr(i:i))
+end do
+Zf90_Set_Unpack_Obj_Multi_Fn7s = Zfw_Set_Fn7s(zz_addr,nbytes,ZOLTAN_UNPACK_OBJ_MULTI_FN_TYPE%choice,fn_ptr,data)
+end function Zf90_Set_Unpack_Obj_Multi_Fn7s
+
+

thirdParty/Zoltan/src/fort/set_unpackobjmulti.if

@@ -0,0 +1,11 @@
+interface Zoltan_Set_Unpack_Obj_Multi_Fn
+   module procedure Zf90_Set_Unpack_Obj_Multi_Fn0s
+   module procedure Zf90_Set_Unpack_Obj_Multi_Fn1s
+   module procedure Zf90_Set_Unpack_Obj_Multi_Fn2s
+   module procedure Zf90_Set_Unpack_Obj_Multi_Fn3s
+   module procedure Zf90_Set_Unpack_Obj_Multi_Fn4s
+   module procedure Zf90_Set_Unpack_Obj_Multi_Fn5s
+   module procedure Zf90_Set_Unpack_Obj_Multi_Fn6s
+   module procedure Zf90_Set_Unpack_Obj_Multi_Fn7s
+end interface
+

thirdParty/Zoltan/src/fort/zoltan_user_data.f90

@@ -0,0 +1,76 @@
+!! 
+!! @HEADER
+!!
+!!!!**********************************************************************
+!!
+!!  Zoltan Toolkit for Load-balancing, Partitioning, Ordering and Coloring
+!!                  Copyright 2012 Sandia Corporation
+!!
+!! Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+!! the U.S. Government retains certain rights in this software.
+!!
+!! Redistribution and use in source and binary forms, with or without
+!! modification, are permitted provided that the following conditions are
+!! met:
+!!
+!! 1. Redistributions of source code must retain the above copyright
+!! notice, this list of conditions and the following disclaimer.
+!!
+!! 2. Redistributions in binary form must reproduce the above copyright
+!! notice, this list of conditions and the following disclaimer in the
+!! documentation and/or other materials provided with the distribution.
+!!
+!! 3. Neither the name of the Corporation nor the names of the
+!! contributors may be used to endorse or promote products derived from
+!! this software without specific prior written permission.
+!!
+!! THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+!! EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+!! IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+!! PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+!! CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+!! EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+!! PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+!! PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+!! LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+!! NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+!! SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+!!
+!! Questions? Contact Karen Devine	kddevin@sandia.gov
+!!                    Erik Boman	egboman@sandia.gov
+!!
+!!!!**********************************************************************
+!!
+!! @HEADER
+ !!
+
+module zoltan_user_data
+use zoltan_types
+implicit none
+
+
+! User defined data types for passing data to the query functions.  These can
+! be used any way you want, but one suggestion is to use them as "wrapper"
+! types for your own user defined types, e.g.
+! type Zoltan_User_Data_1 
+!    type(your_type), pointer :: ptr
+! end type
+! Exactly four data types must be defined, but you don't have to use them.
+
+type Zoltan_User_Data_1
+   integer :: dummy
+end type Zoltan_User_Data_1
+
+type Zoltan_User_Data_2
+   integer :: dummy
+end type Zoltan_User_Data_2
+
+type Zoltan_User_Data_3
+   integer :: dummy
+end type Zoltan_User_Data_3
+
+type Zoltan_User_Data_4
+   integer :: dummy
+end type Zoltan_User_Data_4
+
+end module zoltan_user_data

thirdParty/Zoltan/src/fort/ztypes.f90

@@ -0,0 +1,119 @@
+!! 
+!! @HEADER
+!!
+!!!!**********************************************************************
+!!
+!!  Zoltan Toolkit for Load-balancing, Partitioning, Ordering and Coloring
+!!                  Copyright 2012 Sandia Corporation
+!!
+!! Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+!! the U.S. Government retains certain rights in this software.
+!!
+!! Redistribution and use in source and binary forms, with or without
+!! modification, are permitted provided that the following conditions are
+!! met:
+!!
+!! 1. Redistributions of source code must retain the above copyright
+!! notice, this list of conditions and the following disclaimer.
+!!
+!! 2. Redistributions in binary form must reproduce the above copyright
+!! notice, this list of conditions and the following disclaimer in the
+!! documentation and/or other materials provided with the distribution.
+!!
+!! 3. Neither the name of the Corporation nor the names of the
+!! contributors may be used to endorse or promote products derived from
+!! this software without specific prior written permission.
+!!
+!! THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
+!! EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+!! IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+!! PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
+!! CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+!! EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+!! PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+!! PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+!! LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+!! NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+!! SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+!!
+!! Questions? Contact Karen Devine	kddevin@sandia.gov
+!!                    Erik Boman	egboman@sandia.gov
+!!
+!!!!**********************************************************************
+!!
+!! @HEADER
+ !!
+
+module zoltan_types
+
+!--------------------------------------------------------------------------
+! kind parameters to match Fortran types with C types.
+! This might have to be adjusted on some machines.
+
+integer, parameter :: &
+   Zoltan_INT = selected_int_kind(9), &
+!  Always assume 64-bit pointers.  If sizeof(void*) < 8, extra bytes are
+!  padded to zero in Zfw_Create.
+   Zoltan_INT_PTR = selected_int_kind(17), &
+   Zoltan_FLOAT = selected_real_kind(6), &
+   Zoltan_DOUBLE = selected_real_kind(15)
+
+
+! Always assume 64-bit pointers.  If sizeof(void*) < 8, extra bytes are
+! padded to zero in Zfw_Create.
+integer, parameter :: Zoltan_PTR_LENGTH = 8
+
+type Zoltan_PTR
+   sequence
+   character(len=Zoltan_PTR_LENGTH) :: addr
+end type Zoltan_PTR
+
+type(Zoltan_PTR), parameter :: &
+   Zoltan_NULL_PTR = Zoltan_PTR( &
+                 char(0)//char(0)//char(0)//char(0)// &
+                 char(0)//char(0)//char(0)//char(0))
+
+!--------------------------------------------------------------------------
+! user defined types corresponding to the C structs
+
+type Zoltan_Struct
+   sequence
+   type(Zoltan_PTR) :: addr
+!#ifdef ABSOFT
+! workaround for a bug in the Absoft compiler
+!   integer :: dummy
+!#endif
+end type Zoltan_Struct
+
+interface operator(==)
+   module procedure ptrcompare
+end interface
+
+!  Include this section for backward compatibility with old Zoltan interface.
+integer, parameter :: &
+   LB_INT = Zoltan_INT, &
+   LB_INT_PTR = Zoltan_INT_PTR, &
+   LB_FLOAT = Zoltan_FLOAT, &
+   LB_DOUBLE = Zoltan_DOUBLE
+
+private :: ptrcompare
+
+contains
+
+! comparison operator for C pointers
+
+function ptrcompare(p1,p2)
+logical :: ptrcompare
+type(Zoltan_PTR), intent(in) :: p1, p2
+integer :: i
+! should be able to compare the strings with a single statement
+!   ptrcompare = (p1%addr == p2%addr)
+! but bugs in PGI 3.1-2 and NAG 4.0 require comparing one character
+! at a time
+ptrcompare = .true.
+do i=1,Zoltan_PTR_LENGTH
+   ptrcompare = ptrcompare .and. (p1%addr(i:i) == p2%addr(i:i))
+end do
+end function ptrcompare
+
+end module zoltan_types