8 #include <stk_mesh/base/Field.hpp> 9 #include <stk_mesh/base/FieldData.hpp> 10 #include <stk_mesh/base/Entity.hpp> 11 #include <stk_mesh/base/Bucket.hpp> 12 #include <stk_mesh/base/BulkData.hpp> 13 #include <stk_mesh/fem/FEMMetaData.hpp> 15 #include <stk_util/parallel/ParallelReduce.hpp> 19 #include <Teuchos_ParameterList.hpp> 25 #define STK_GEOMDECOMP_DEBUG 0 30 double static_zoltan_version(
const double v=0) {
31 static double version=0;
36 inline unsigned num_gid_entries() {
37 static const unsigned n=2;
41 inline unsigned num_lid_entries() {
42 static const unsigned n=2;
45 inline unsigned wdim() {
46 static const unsigned n=1;
50 inline void convert_param_to_string(
const Parameters &from,
51 vector < pair<std::string, std::string> > &to)
53 Parameters::ConstIterator
54 from_iter = from.begin(),
55 from_end = from.end();
57 for (; from_iter != from_end; ++from_iter) {
59 const std::string name = from.name(from_iter);
60 const std::string entry = from.entry(from_iter).getValue(&s);
61 std::pair<std::string,std::string> p(name,entry);
67 inline void fill_parameters (
const char *T[][2],
71 for (
int j=0; j<i; ++j) Entry.set(T[j][0], T[j][1]);
74 void fill_name_conversion( Parameters & name_conversion )
77 Parameters & general = name_conversion.sublist(
"General");
79 general.set(
"LOAD BALANCING METHOD" ,
"LB_METHOD");
80 general.set(
"ZOLTAN DEBUG LEVEL" ,
"DEBUG_LEVEL");
81 general.set(
"DEBUG PROCESSOR NUMBER" ,
"DEBUG_PROCESSOR");
82 general.set(
"TIMER" ,
"TIMER");
83 general.set(
"DETERMINISTIC DECOMPOSITION",
"DETERMINISTIC");
84 general.set(
"DEBUG MEMORY" ,
"DEBUG_MEMORY");
85 general.set(
"IMBALANCE TOLERANCE" ,
"IMBALANCE_TOL");
86 general.set(
"RENUMBER PARTITIONS" ,
"REMAP");
87 general.set(
"KEEP CUTS" ,
"KEEP_CUTS");
88 general.set(
"REUSE CUTS" ,
"RCB_REUSE");
89 general.set(
"RCB RECOMPUTE BOX" ,
"RCB_RECOMPUTE_BOX");
90 general.set(
"CHECK GEOMETRY" ,
"CHECK_GEOM");
91 general.set(
"LOCK RCB DIRECTIONS" ,
"RCB_LOCK_DIRECTIONS");
92 general.set(
"SET RCB DIRECTIONS" ,
"RCB_SET_DIRECTIONS");
93 general.set(
"RCB MAX ASPECT RATIO" ,
"RCB_MAX_ASPECT_RATIO");
94 general.set(
"RECTILINEAR RCB BLOCKS" ,
"RCB_RECTILINEAR_BLOCKS");
95 general.set(
"OCTREE DIMENSION" ,
"OCT_DIM");
96 general.set(
"OCTREE METHOD" ,
"OCT_METHOD");
97 general.set(
"OCTREE MIN ENTITIES" ,
"OCT_MINOBJECTS");
98 general.set(
"OCTREE MAX ENTITIES" ,
"OCT_MAXOBJECTS");
101 general.set(
"NUMBER GLOBAL ID ENTRIES" ,
"NUM_GID_ENTRIES");
102 general.set(
"NUMBER LOCAL ID ENTRIES" ,
"NUM_LID_ENTRIES");
103 general.set(
"ENTITY WEIGHT DIMENSION" ,
"OBJ_WEIGHT_DIM");
104 general.set(
"RETURN LISTS" ,
"RETURN_LISTS");
105 general.set(
"AUTOMATIC MIGRATION" ,
"AUTO_MIGRATE");
106 general.set(
"DISTANCE" ,
"DISTANCE");
108 Parameters & rcb = name_conversion.sublist(
"0");
109 rcb.set(
"OVER ALLOCATE MEMORY" ,
"RCB_OVERALLOC");
110 rcb.set(
"ALGORITHM DEBUG LEVEL" ,
"RCB_OUTPUT_LEVEL");
112 Parameters & rib = name_conversion.sublist(
"1");
113 rib.set(
"OVER ALLOCATE MEMORY" ,
"RIB_OVERALLOC");
114 rib.set(
"ALGORITHM DEBUG LEVEL" ,
"RIB_OUTPUT_LEVEL");
116 Parameters & hsfc = name_conversion.sublist(
"2");
117 hsfc.set(
"OVER ALLOCATE MEMORY" ,
"");
118 hsfc.set(
"ALGORITHM DEBUG LEVEL" ,
"" );
120 Parameters & oct = name_conversion.sublist(
"3");
121 oct.set(
"OVER ALLOCATE MEMORY" ,
"");
122 oct.set(
"ALGORITHM DEBUG LEVEL" ,
"OCT_OUTPUT_LEVEL");
124 Parameters & graph = name_conversion.sublist(
"4");
125 graph.set(
"OVER ALLOCATE MEMORY" ,
"");
126 graph.set(
"ALGORITHM DEBUG LEVEL" ,
"" );
130 void fill_value_conversion( Parameters & value_conversion )
132 Parameters & lb_method = value_conversion.sublist(
"LOAD BALANCING METHOD");
133 lb_method.set(
"0" ,
"RCB");
134 lb_method.set(
"1" ,
"RIB");
135 lb_method.set(
"2" ,
"HSFC");
136 lb_method.set(
"3" ,
"OCTPART");
137 lb_method.set(
"4" ,
"GRAPH");
139 Parameters & timer = value_conversion.sublist(
"TIMER");
140 timer.set(
"0" ,
"WALL");
141 timer.set(
"1" ,
"CPU");
145 void fill_default_values( Parameters & values )
147 Parameters & default_values = values;
149 default_values.set(
"LOAD BALANCING METHOD" ,
"0");
150 default_values.set(
"RENUMBER PARTITIONS" ,
"1");
151 default_values.set(
"ZOLTAN DEBUG LEVEL" ,
"0");
152 default_values.set(
"TIMER" ,
"0");
153 default_values.set(
"DETERMINISTIC DECOMPOSITION",
"1");
154 default_values.set(
"DEBUG MEMORY" ,
"1");
155 default_values.set(
"IMBALANCE TOLERANCE" ,
"1.1");
156 default_values.set(
"KEEP CUTS" ,
"1");
157 default_values.set(
"REUSE CUTS" ,
"1");
158 default_values.set(
"OVER ALLOCATE MEMORY" ,
"1.1");
159 default_values.set(
"ALGORITHM DEBUG LEVEL" ,
"0");
162 default_values.set(
"NUMBER GLOBAL ID ENTRIES" ,
"2");
163 default_values.set(
"NUMBER LOCAL ID ENTRIES" ,
"2");
164 default_values.set(
"ENTITY WEIGHT DIMENSION" ,
"1");
165 default_values.set(
"RETURN LISTS" ,
"EXPORT");
170 #if STK_GEOMDECOMP_DEBUG>=2 171 void debug_print_decomp_export(Zoltan *zoltan,
175 int num_export = zoltan->Num_Exported();
176 ZOLTAN_ID_PTR export_lids = zoltan->Export_Local_IDs();
177 ZOLTAN_ID_PTR export_gids = zoltan->Export_Global_IDs();
178 int* export_procs = zoltan->Export_Proc_IDs();
179 int Z_LID_SIZE = zoltan->Num_Lid_Entries();
180 int Z_GID_SIZE = zoltan->Num_Gid_Entries();
182 if ( export_gids!=NULL && export_lids!=NULL && export_procs!=NULL ) {
183 Env::output() <<
": Zoltan RCB EXPORTS" << std::endl;
184 for ( i = 0; i < num_export; i++ ) {
188 <<
"T" << zoltan_id->Type( &export_gids[i*Z_GID_SIZE]) <<
" " 189 <<
"I" << zoltan_id->Index(&export_gids[i*Z_GID_SIZE]) <<
" " 190 <<
"P" << zoltan_id->Proc( &export_gids[i*Z_GID_SIZE]) <<
" " 192 <<
"T" << zoltan_id->Type( &export_lids[i*Z_LID_SIZE]) <<
" " 193 <<
"I" << zoltan_id->Index(&export_lids[i*Z_LID_SIZE]) <<
" " 194 <<
" EXPORT_PROC_ID = " 206 int stkCallback_Num_Elements(
void *data,
int *ierr );
207 void stkCallback_Element_List(
void *data,
210 ZOLTAN_ID_PTR global_ids,
211 ZOLTAN_ID_PTR local_ids,
215 int stkCallback_Num_Dimensions(
void *data,
int *ierr );
216 void stkCallback_Centroid_Coord(
void *data,
219 ZOLTAN_ID_PTR global_id,
220 ZOLTAN_ID_PTR local_id,
223 int stkCallback_Num_Edges(
void *data,
226 ZOLTAN_ID_PTR global_id,
227 ZOLTAN_ID_PTR local_id,
229 void stkCallback_Edge_List(
void *data,
232 ZOLTAN_ID_PTR global_id,
233 ZOLTAN_ID_PTR local_id,
234 ZOLTAN_ID_PTR nbor_global_id,
242 int stkCallback_Num_Elements(
void *data,
int *ierr )
244 if ( data == NULL ) {
245 *ierr = ZOLTAN_FATAL;
249 stk_classic::rebalance::Zoltan *zdata =
dynamic_cast<stk_classic::rebalance::Zoltan*
>(gdata);
251 if (zdata == NULL ) {
252 *ierr = ZOLTAN_FATAL;
262 void stkCallback_Element_List(
void *data,
265 ZOLTAN_ID_PTR global_ids,
266 ZOLTAN_ID_PTR local_ids,
272 *ierr = ZOLTAN_FATAL;
277 stk_classic::rebalance::Zoltan *zdata =
dynamic_cast<stk_classic::rebalance::Zoltan*
> (gdata);
280 *ierr = ZOLTAN_FATAL;
285 const unsigned num_local_ids = zdata->num_moid();
286 for (
unsigned j=0; j<num_local_ids; ++j) {
291 global_ids[k] =
static_cast<ZOLTAN_ID_TYPE
>(zdata->globalID(j));
294 weights[l++] = zdata->entity_weight(j);
304 int stkCallback_Num_Dimensions(
void *data,
int *ierr )
307 *ierr = ZOLTAN_FATAL;
311 stk_classic::rebalance::Zoltan *zdata =
dynamic_cast<stk_classic::rebalance::Zoltan*
> (gdata);
314 *ierr = ZOLTAN_FATAL;
318 const int nd = zdata->spatial_dimension();
325 void stkCallback_Centroid_Coord(
void *data,
328 ZOLTAN_ID_PTR global_id,
329 ZOLTAN_ID_PTR local_id,
333 std::vector<double> temp(3,0.0);
340 *ierr = ZOLTAN_FATAL;
344 stk_classic::rebalance::Zoltan *zdata =
dynamic_cast<stk_classic::rebalance::Zoltan*
> (gdata);
347 *ierr = ZOLTAN_FATAL;
351 int lid = local_id[ 0 ];
353 const mesh::Entity & target_entity = * zdata->mesh_entity( lid );
355 const unsigned nd = zdata->spatial_dimension();
364 rebalance::GeomDecomp::entity_to_point( target_entity, coor, temp );
366 for (
size_t i=0 ; i < nd ; i++ ) geom[ i ] = (
double) temp[ i ];
374 std::set<const mesh::Entity*> & nodes )
377 const stk_classic::mesh::EntityRank element_rank = fem_meta.
element_rank();
383 for ( ; iElem.first != iElem.second; ++iElem.first ) {
386 for ( ; iNode.first != iNode.second; ++iNode.first ) {
388 if (&entity != node) nodes.insert( node );
395 std::set<const mesh::Entity*> nodes;
397 getNeighbors( entity, nodes );
401 int stkCallback_Num_Edges(
void *data,
404 ZOLTAN_ID_PTR global_id,
405 ZOLTAN_ID_PTR local_id,
415 *ierr = ZOLTAN_FATAL;
419 stk_classic::rebalance::Zoltan *zdata =
dynamic_cast<stk_classic::rebalance::Zoltan*
> (gdata);
422 *ierr = ZOLTAN_FATAL;
426 int lid = local_id[ 0 ];
428 const mesh::Entity & target_entity = * zdata->mesh_entity( lid );
430 return numEdges( target_entity );
434 void stkCallback_Edge_List(
void *data,
437 ZOLTAN_ID_PTR global_id,
438 ZOLTAN_ID_PTR local_id,
441 ZOLTAN_ID_PTR nbor_global_id,
455 *ierr = ZOLTAN_FATAL;
459 stk_classic::rebalance::Zoltan *zdata =
dynamic_cast<stk_classic::rebalance::Zoltan*
> (gdata);
462 *ierr = ZOLTAN_FATAL;
466 int lid = local_id[ 0 ];
468 const mesh::Entity & target_entity = * zdata->mesh_entity( lid );
470 std::set<const mesh::Entity*> nodes;
471 getNeighbors( target_entity, nodes );
474 for ( std::set<const mesh::Entity*>::iterator i = nodes.begin();
475 i != nodes.end(); ++i ) {
476 nbor_global_id[counter*2+0] = 0;
479 nbor_global_id[counter*2+1] = n.
key().id();
494 const std::string Zoltan::m_zoltanparametersname_=
"Zoltan_Parameters";
495 const std::string Zoltan::m_defaultparametersname_=
"DEFAULT";
498 const std::string Zoltan::zoltan_parameters_name()
500 return m_zoltanparametersname_;
503 const std::string Zoltan::default_parameters_name()
505 return m_defaultparametersname_;
508 void Zoltan::init_default_parameters()
510 fill_default_values(m_default_parameters_);
514 static Parameters *Name_Conversion =NULL;
515 static Parameters *Value_Conversion=NULL;
517 double Zoltan::zoltan_version()
const {
return static_zoltan_version(); }
524 void merge_parameters(std::vector <std::pair<std::string, std::string> > &str_zoltan_params,
525 const Parameters &Zoltan_Params) {
526 Parameters Merged_Zoltan_Params ;
527 Parameters Converted_Zoltan_Params;
529 rebalance::Zoltan::merge_default_values (Zoltan_Params,
530 Merged_Zoltan_Params);
532 rebalance::Zoltan::convert_names_and_values(Merged_Zoltan_Params,
533 Converted_Zoltan_Params);
535 convert_param_to_string (Converted_Zoltan_Params,
541 Zoltan::Zoltan(
ParallelMachine pm,
const unsigned ndim, Parameters & rebal_region_parameters,
const std::string parameters_name) :
544 m_spatial_dimension_(ndim),
545 m_total_number_entities_(0)
548 if( !rebal_region_parameters.isSublist(default_parameters_name()) )
550 init_default_parameters();
551 rebal_region_parameters.sublist(default_parameters_name()) = m_default_parameters_;
555 std::string default_name =
556 (parameters_name.empty()) ? default_parameters_name() : parameters_name ;
558 if( !rebal_region_parameters.isSublist(default_name) ) {
559 throw std::runtime_error(
"The Zoltan parameter set '" + default_name +
"' does not exist.");
561 const Parameters & zoltan_params = rebal_region_parameters.sublist(default_name);
563 std::vector <std::pair<std::string, std::string> > str_zoltan_params;
564 merge_parameters(str_zoltan_params, zoltan_params);
566 init(str_zoltan_params);
570 Zoltan::set_mesh_info(
const std::vector<mesh::Entity *> &mesh_entities,
577 m_total_number_entities_ = mesh_entities.size();
579 mesh_info.mesh_entities = mesh_entities;
580 mesh_info.nodal_coord_ref = nodal_coord_ref;
581 mesh_info.elem_weight_ref = elem_weight_ref;
590 m_mesh_information_ = mesh_info;
593 void Zoltan::init(
const vector< pair<std::string,std::string> >
594 &dynamicLoadRebalancingParameters ) {
595 if (0==static_zoltan_version()) {
596 const double v = init_zoltan_library();
597 static_zoltan_version(v);
604 m_zoltan_id_ = Zoltan_Create( comm_ );
605 if ( m_zoltan_id_ == NULL ) {
606 throw runtime_error (
"(FATAL ERROR) Zoltan_Create() returned NULL");
613 vector<pair<std::string,std::string> >::const_iterator
614 P = dynamicLoadRebalancingParameters.begin(),
615 PE = dynamicLoadRebalancingParameters.end();
617 for ( ; PE != P ; P++ ) {
619 char * label =
const_cast<char*
>( P->first.c_str() ) ;
620 char * value =
const_cast<char*
>( P->second.c_str() ) ;
622 if (ZOLTAN_OK != (Zoltan_Set_Param(m_zoltan_id_,label,value)))
624 throw runtime_error(
": FATAL ERROR returned from Zoltan_Set_Param ");
631 if ( ZOLTAN_OK != register_callbacks() )
632 throw runtime_error (
"zoltan->Register_Callbacks error. ");
634 #if STK_GEOMDECOMP_DEBUG>=2 636 debug_print_decomp_export( zoltan, m_zoltan_id_ );
643 double Zoltan::init_zoltan_library () {
645 if ( Zoltan_Initialize( 0, NULL, &version) != ZOLTAN_OK )
646 throw std::runtime_error(
"Return code from Zoltan_Initialize() != ZOLTAN_OK ");
648 static_zoltan_version(version);
649 std::ostringstream s;
665 if ( m_zoltan_id_ != NULL ) {
666 Zoltan_Destroy( &m_zoltan_id_ );
668 m_zoltan_id_ = NULL ;
669 if(Name_Conversion) {
670 delete Name_Conversion;
671 Name_Conversion = NULL;
673 if(Value_Conversion) {
674 delete Value_Conversion;
675 Value_Conversion = NULL;
680 Zoltan::reset_dest_proc_data()
683 const unsigned size = m_mesh_information_.mesh_entities.size();
684 m_mesh_information_.dest_proc_ids.assign(size, proc);
688 Zoltan::set_destination_proc(
const unsigned moid,
689 const unsigned proc )
691 m_mesh_information_.dest_proc_ids[ moid ] = proc;
695 Zoltan::destination_proc(
const unsigned moid)
const 697 return m_mesh_information_.dest_proc_ids[ moid ];
701 Zoltan::find_mesh_entity(
const mesh::Entity * entity,
unsigned & moid)
const 703 unsigned len = m_mesh_information_.mesh_entities.size();
704 for(moid = 0; moid < len; ++moid)
706 if(m_mesh_information_.mesh_entities[moid] == entity)
return true;
712 Zoltan::get_new_partition(stk_classic::mesh::EntityProcVec &rebal_spec)
714 const unsigned entity_iter_len = m_mesh_information_.mesh_entities.size();
715 for (
unsigned entity_iter =0; entity_iter != entity_iter_len; ++entity_iter) {
717 int proc = destination_proc(entity_iter);
719 rebal_spec.push_back(et);
725 Zoltan::entity_coord_ref()
const 727 return m_mesh_information_.nodal_coord_ref;
731 Zoltan::mesh_entity(
const unsigned moid )
const 733 return m_mesh_information_.mesh_entities[ moid ];
737 Zoltan::entity_weight(
const unsigned moid )
const 739 double mo_weight = 1.0;
740 if (entity_weight_ref()) {
741 mo_weight = *
static_cast<double *
> 742 (
mesh::field_data (*entity_weight_ref(), *m_mesh_information_.mesh_entities[ moid ]));
748 Zoltan::entity_weight_ref()
const 750 return m_mesh_information_.elem_weight_ref;
754 Zoltan::num_moid()
const 756 return m_mesh_information_.mesh_entities.size() ;
759 const std::string &Zoltan::parameter_entry_name()
const 761 return m_parameter_entry_name_;
767 int Zoltan::register_callbacks()
787 if ( Zoltan_Set_Num_Obj_Fn( m_zoltan_id_,
788 stkCallback_Num_Elements,
791 throw std::runtime_error(
"Zoltan_Set_Num_Obj_Fn using stkCallback_Num_Elements failed to register");
793 if ( Zoltan_Set_Obj_List_Fn( m_zoltan_id_, stkCallback_Element_List,
this )
795 throw std::runtime_error(
"Zoltan_Set_Obj_List_Fn using stkCallback_Element_List");
797 if ( Zoltan_Set_Num_Geom_Fn( m_zoltan_id_, stkCallback_Num_Dimensions,
this )
799 throw std::runtime_error(
"Zoltan_Set_Num_Geom_Fn using stkCallback_Num_Dimensions");
801 if ( Zoltan_Set_Geom_Fn( m_zoltan_id_, stkCallback_Centroid_Coord,
this )
803 throw std::runtime_error(
"Zoltan_Set_Geom_Fn using stkCallback_Centroid_Coord");
805 if ( Zoltan_Set_Num_Edges_Fn( m_zoltan_id_, stkCallback_Num_Edges,
this )
807 throw std::runtime_error(
"Zoltan_Set_Num_Edges_Fn using stkCallback_Num_Edges");
809 if ( Zoltan_Set_Edge_List_Fn( m_zoltan_id_, stkCallback_Edge_List,
this )
811 throw std::runtime_error(
"Zoltan_Set_Edge_List_Fn using stkCallback_Edge_List");
819 int Zoltan::evaluate(
int print_stats,
829 ZOLTAN_BALANCE_EVAL eval = {0};
830 ZOLTAN_GRAPH_EVAL graph = {{0}};
831 if (Zoltan_LB_Eval_Balance( m_zoltan_id_, print_stats, &eval)) ierr = 1;
832 if (Zoltan_LB_Eval_Graph( m_zoltan_id_, print_stats, &graph) ) ierr = 1;
833 *nentity = (int)eval.nobj[0];
834 *entity_wgt = eval.obj_wgt[0];
835 *ncuts = (
int)graph.cuts[0];
836 *cut_wgt = graph.cut_wgt[0];
837 *nboundary = (int)graph.num_boundary[0];
838 *nadj = (
int)graph.nnborparts[0];
844 void Zoltan::determine_new_partition (
bool &RebalancingNeeded)
855 int length_gid, length_lid;
859 ZOLTAN_ID_PTR import_gids;
860 ZOLTAN_ID_PTR import_lids;
861 int *import_procs=NULL;
863 ZOLTAN_ID_PTR export_gids;
864 ZOLTAN_ID_PTR export_lids;
865 int *export_procs=NULL;
924 int status = Zoltan_LB_Balance( m_zoltan_id_, &new_decomp,
925 &length_gid , &length_lid,
926 &num_imported, &import_gids,
927 &import_lids, &import_procs,
928 &num_exported, &export_gids,
929 &export_lids, &export_procs );
930 if (status != ZOLTAN_OK) {
931 throw std::runtime_error(
"Zoltan_Balance() returned error code " + status);
935 reset_dest_proc_data();
937 int actual_exported = 0;
938 if ( new_decomp && ( num_exported != -1 ) ) {
941 for (
int j=0; j < num_exported; ++j ) {
946 const unsigned lid = export_lids[ j*::num_lid_entries() ];
947 const unsigned pid = export_procs[ j ];
951 set_destination_proc(lid,
pid);
956 RebalancingNeeded = 0 ;
960 if (rebalneeded) RebalancingNeeded = 1;
967 Zoltan_LB_Free_Data( &import_gids, &import_lids, &import_procs,
968 &export_gids, &export_lids, &export_procs )) {
969 throw runtime_error (
" FATAL ERROR in Zoltan_LB_Free_Data.");
974 void Zoltan::convert_names_and_values(
const Parameters &from, Parameters &to)
977 if (!Name_Conversion) {
978 Name_Conversion =
new Parameters;
979 fill_name_conversion (*Name_Conversion);
981 if (!Value_Conversion) {
982 Value_Conversion =
new Parameters;
983 fill_value_conversion(*Value_Conversion);
988 std::string algorithm;
989 const std::string keyname(
"LOAD BALANCING METHOD");
990 if( from.isParameter(keyname) )
991 algorithm = from.get<std::string>(keyname);
995 const Parameters & General = Name_Conversion->sublist(
"General");
996 const Parameters & Algorithm = Name_Conversion->sublist(algorithm);
998 Parameters::ConstIterator
999 from_iter = from.begin(),
1000 from_end = from.end();
1004 for (; from_iter != from_end; ++from_iter) {
1006 from_name = from.name(from_iter),
1012 if (General.isParameter(from_name)) {
1013 to_name = General.get<std::string>(from_name);
1015 to_name = Algorithm.get<std::string>(from_name);
1022 std::string to_value = Teuchos::getValue<string>(from.entry(from_iter));
1024 if (Value_Conversion->isParameter(from_name)) to_value = Value_Conversion->sublist(from_name).get<std::string>(to_value);
1025 if (!to_name.empty()) to.set(to_name, to_value);
1029 void Zoltan::merge_default_values(
const Parameters &from,
1032 Parameters default_values;
1033 fill_default_values(default_values);
1034 to.setParameters(default_values);
1035 to.setParameters(from);
std::ostream & output()
Function output returns the processor output log stream. This stream is connected via an mpi_filebuf ...
FieldTraits< field_type >::data_type * field_data(const field_type &f, const Bucket::iterator i)
Pointer to the field data array.
void all_reduce_sum(ParallelMachine comm, const double *local, double *global, unsigned count)
Parallel summation to all processors.
int pid()
Function pid returns the process id of the process running the application.
const EntityKey & key() const
The globally unique key ( entity type + identifier ) of this entity.
std::pair< Entity *, unsigned > EntityProc
Pairing of an entity with a processor rank.
int parallel_rank()
function parallel_rank returns the rank of this processor in the current mpi communicator.
Field with defined data type and multi-dimensions (if any)
unsigned parallel_machine_rank(ParallelMachine parallel_machine)
Member function parallel_machine_rank ...
PairIterRelation relations() const
All Entity relations for which this entity is a member. The relations are ordered from lowest entity-...
A fundamental unit within the discretization of a problem domain, including but not limited to nodes...
virtual unsigned num_elems() const =0
Return the total number of mesh entities in all lists.
Class for determining the optimal partitioning of mesh entities.
void output_flush()
Function output_flush flushes all output on all currently open synchronous outptu files which were op...
unsigned owner_rank() const
Parallel processor rank of the processor which owns this entity.