Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members

Isorropia::Epetra Namespace Reference

The Epetra namespace contains Isorropia's Epetra-specific classes and functions. More...


Classes

class  Isorropia::Epetra::CostDescriber
 An Epetra-specific implementation of Isorropia::CostDescriber. More...
class  Isorropia::Epetra::Partitioner
 An Epetra-specific implementation of the Partitioner interface. More...

Functions

Teuchos::RefCountPtr< Isorropia::Partitioner > create_partitioner (Teuchos::RefCountPtr< const Epetra_CrsGraph > input_graph, const Teuchos::ParameterList &paramlist)
 Given an input matrix-graph that is to be repartitioned, and a parameter- list (possibly specifying things such as the partitioning package/method), create an instance of Isorropia::Partitioner.
Teuchos::RefCountPtr< Isorropia::Partitioner > create_partitioner (Teuchos::RefCountPtr< const Epetra_CrsGraph > input_graph, Teuchos::RefCountPtr< const Isorropia::CostDescriber > costs, const Teuchos::ParameterList &paramlist)
 Given an input matrix-graph that is to be repartitioned, and a parameter- list (possibly specifying the partitioning package/method etc.), create an instance of Isorropia::Partitioner.
Teuchos::RefCountPtr< Isorropia::Partitioner > create_partitioner (Teuchos::RefCountPtr< const Epetra_RowMatrix > input_matrix, const Teuchos::ParameterList &paramlist)
 Given an input row-matrix that is to be repartitioned, and a parameter- list (possibly specifying the partitioning package/method etc.), create an instance of Isorropia::Partitioner.
Teuchos::RefCountPtr< Isorropia::Partitioner > create_partitioner (Teuchos::RefCountPtr< const Epetra_RowMatrix > input_matrix, Teuchos::RefCountPtr< const Isorropia::CostDescriber > costs, const Teuchos::ParameterList &paramlist)
 Given an input row-matrix that is to be repartitioned, and a parameter- list (possibly specifying the partitioning package/method etc.), create an instance of Isorropia::Partitioner.
Teuchos::RefCountPtr< Epetra_Map > create_target_map (const Epetra_Comm &comm, Partitioner &partitioner)
 Given a Partitioner object, create a target map representing the new partitioning.
Teuchos::RefCountPtr< Epetra_CrsMatrix > create_balanced_copy (const Epetra_CrsMatrix &input_matrix, Teuchos::ParameterList &paramlist)
 Create a balanced copy of an input Epetra_CrsMatrix.
Teuchos::RefCountPtr< Epetra_CrsMatrix > create_balanced_copy (const Epetra_RowMatrix &input_matrix)
 Create a balanced copy of an input Epetra_RowMatrix.
Teuchos::RefCountPtr< Epetra_CrsMatrix > create_balanced_copy (const Epetra_CrsMatrix &input_matrix, const Epetra_Vector &row_weights)
 Create a balanced copy of an input Epetra_CrsMatrix, accounting for user-supplied weights assigned to each row.
Teuchos::RefCountPtr< Epetra_CrsMatrix > create_balanced_copy (const Epetra_RowMatrix &input_matrix, const Epetra_Vector &row_weights)
 Create a balanced copy of an input Epetra_RowMatrix, accounting for user-supplied weights assigned to each row.
Teuchos::RefCountPtr< Epetra_CrsGraph > create_balanced_copy (const Epetra_CrsGraph &input_graph, Teuchos::ParameterList &paramlist)
 Create a balanced copy of an input Epetra_CrsGraph.
Teuchos::RefCountPtr< Epetra_CrsGraph > create_balanced_copy (const Epetra_CrsGraph &input_graph, const Epetra_Vector &row_weights)
 Create a balanced copy of an input Epetra_CrsGraph, accounting for user-supplied weights assigned to each row.
Teuchos::RefCountPtr< Epetra_LinearProblem > create_balanced_copy (const Epetra_LinearProblem &input_problem)
 Create a balanced copy of an input Epetra_LinearProblem.
Teuchos::RefCountPtr< Epetra_CrsMatrix > redistribute_rows (const Epetra_CrsMatrix &input_matrix, const Epetra_Map &target_rowmap, Epetra_Import *importer=0)
 Return a new Epetra_CrsMatrix object constructed with target_rowmap, and with the contents of input_matrix imported into it.
Teuchos::RefCountPtr< Epetra_CrsMatrix > redistribute_rows (const Epetra_RowMatrix &input_matrix, const Epetra_Map &target_rowmap, Epetra_Import *importer=0)
 Return a new Epetra_CrsMatrix object constructed with target_rowmap, and with the contents of input_matrix imported into it.
Teuchos::RefCountPtr< Epetra_CrsGraph > redistribute_rows (const Epetra_CrsGraph &input_graph, const Epetra_Map &target_rowmap, Epetra_Import *importer=0)
 Return a new Epetra_CrsGraph object constructed with target_rowmap, and with the contents of input_graph imported into it.
Teuchos::RefCountPtr< Epetra_MultiVector > redistribute (const Epetra_MultiVector &input, const Epetra_BlockMap &target_map, Epetra_Import *importer=0)
 Return a new Epetra_MultiVector object constructed with target_map, and with the contents of 'input' imported into it.
Teuchos::RefCountPtr< Epetra_Vector > redistribute (const Epetra_Vector &input, const Epetra_Map &target_map, Epetra_Import *importer=0)
 Return a new Epetra_Vector object constructed with target_map, and with the contents of 'input' imported into it.

Detailed Description

The Epetra namespace contains Isorropia's Epetra-specific classes and functions.

Function Documentation

Teuchos::RefCountPtr<Isorropia::Partitioner> create_partitioner (  Teuchos::RefCountPtr< const Epetra_CrsGraph >  input_graph,
const Teuchos::ParameterList &  paramlist
) 
 

Given an input matrix-graph that is to be repartitioned, and a parameter- list (possibly specifying things such as the partitioning package/method), create an instance of Isorropia::Partitioner.

This is a factory function, the run-time type of the returned Partitioner is Isorropia::EpetraPartitioner.

If Isorropia has been configured with Zoltan support, then Zoltan will be used as the underlying partitioner by default. Otherwise, the simple linear built-in partitioner will be used. To specify that Zoltan be used as the underlying partitioner, create a sublist named "Zoltan" in the ParameterList object. Then, in that sublist, put any parameters that should be relayed straight to Zoltan. Refer to the Zoltan users guide for specific parameters that Zoltan recognizes. A couple of important ones are "LB_METHOD" (valid values include "GRAPH", "HYPERGRAPH"), "DEBUG_LEVEL" (valid values are 0 to 10, default is 1), etc.

Teuchos::RefCountPtr<Isorropia::Partitioner> create_partitioner (  Teuchos::RefCountPtr< const Epetra_CrsGraph >  input_graph,
Teuchos::RefCountPtr< const Isorropia::CostDescriber >  costs,
const Teuchos::ParameterList &  paramlist
) 
 

Given an input matrix-graph that is to be repartitioned, and a parameter- list (possibly specifying the partitioning package/method etc.), create an instance of Isorropia::Partitioner.

This is a factory function, the run-time type of the returned Partitioner is Isorropia::EpetraPartitioner.

If Isorropia has been configured with Zoltan support, then Zoltan will be used as the underlying partitioner by default. Otherwise, the simple linear built-in partitioner will be used. To specify that Zoltan be used as the underlying partitioner, create a sublist named "Zoltan" in the ParameterList object. Then, in that sublist, put any parameters that should be relayed straight to Zoltan. Refer to the Zoltan users guide for specific parameters that Zoltan recognizes. A couple of important ones are "LB_METHOD" (valid values include "GRAPH", "HYPERGRAPH"), "DEBUG_LEVEL" (valid values are 0 to 10, default is 1), etc.

Teuchos::RefCountPtr<Isorropia::Partitioner> create_partitioner (  Teuchos::RefCountPtr< const Epetra_RowMatrix >  input_matrix,
const Teuchos::ParameterList &  paramlist
) 
 

Given an input row-matrix that is to be repartitioned, and a parameter- list (possibly specifying the partitioning package/method etc.), create an instance of Isorropia::Partitioner.

This is a factory function, the run-time type of the returned Partitioner is Isorropia::EpetraPartitioner.

If Isorropia has been configured with Zoltan support, then Zoltan will be used as the underlying partitioner by default. Otherwise, the simple linear built-in partitioner will be used. To specify that Zoltan be used as the underlying partitioner, create a sublist named "Zoltan" in the ParameterList object. Then, in that sublist, put any parameters that should be relayed straight to Zoltan. Refer to the Zoltan users guide for specific parameters that Zoltan recognizes. A couple of important ones are "LB_METHOD" (valid values include "GRAPH", "HYPERGRAPH"), "DEBUG_LEVEL" (valid values are 0 to 10, default is 1), etc.

Teuchos::RefCountPtr<Isorropia::Partitioner> create_partitioner (  Teuchos::RefCountPtr< const Epetra_RowMatrix >  input_matrix,
Teuchos::RefCountPtr< const Isorropia::CostDescriber >  costs,
const Teuchos::ParameterList &  paramlist
) 
 

Given an input row-matrix that is to be repartitioned, and a parameter- list (possibly specifying the partitioning package/method etc.), create an instance of Isorropia::Partitioner.

This is a factory function, the run-time type of the returned Partitioner is Isorropia::EpetraPartitioner.

If Isorropia has been configured with Zoltan support, then Zoltan will be used as the underlying partitioner by default. Otherwise, the simple linear built-in partitioner will be used. To specify that Zoltan be used as the underlying partitioner, create a sublist named "Zoltan" in the ParameterList object. Then, in that sublist, put any parameters that should be relayed straight to Zoltan. Refer to the Zoltan users guide for specific parameters that Zoltan recognizes. A couple of important ones are "LB_METHOD" (valid values include "GRAPH", "HYPERGRAPH"), "DEBUG_LEVEL" (valid values are 0 to 10, default is 1), etc.

Teuchos::RefCountPtr<Epetra_Map> create_target_map (  const Epetra_Comm &  comm,
Partitioner &  partitioner
) 
 

Given a Partitioner object, create a target map representing the new partitioning.

This function calls partitioner.compute_partitioning() if it has not already been called.

Teuchos::RefCountPtr<Epetra_CrsMatrix> create_balanced_copy (  const Epetra_CrsMatrix &  input_matrix,
Teuchos::ParameterList &  paramlist
) 
 

Create a balanced copy of an input Epetra_CrsMatrix.

This function represents a basic case, not accepting weights. By default, it uses a self-contained internal implementation rather than interfacing to a third-party library such as Zoltan.

If Isorropia has been configured with Zoltan support, then Zoltan will be used as the underlying partitioner by default. Otherwise, the simple linear built-in partitioner will be used. Any parameters in a "Zoltan" sublist of the parameter-list will be relayed directly to Zoltan. Refer to the Zoltan users guide for specific parameters that Zoltan recognizes. A couple of important ones are "LB_METHOD" (valid values include "GRAPH", "HYPERGRAPH"), "DEBUG_LEVEL" (valid values are 0 to 10, default is 1), etc.

The rebalancing is 1-D, row-wise, and attempts to make the number of nonzeros equal in each partition. I.e., it is equivalent to specifying a weighted rebalance where the weights are the number of nonzeros in each row.

Teuchos::RefCountPtr<Epetra_CrsMatrix> create_balanced_copy (  const Epetra_RowMatrix &  input_matrix  ) 
 

Create a balanced copy of an input Epetra_RowMatrix.

This function represents the most basic default case, not accepting parameters or weights, and uses a self-contained internal implementation rather than interfacing to a third-party library such as Zoltan.

The rebalancing is 1-D, row-wise, and attempts to make the number of nonzeros equal in each partition. I.e., it is equivalent to specifying a weighted rebalance where the weights are the number of nonzeros in each row.

Teuchos::RefCountPtr<Epetra_CrsMatrix> create_balanced_copy (  const Epetra_CrsMatrix &  input_matrix,
const Epetra_Vector &  row_weights
) 
 

Create a balanced copy of an input Epetra_CrsMatrix, accounting for user-supplied weights assigned to each row.

This function uses a self-contained internal implementation rather than interfacing to a third-party library such as Zoltan.

The rebalancing is 1-D, row-wise, and attempts to assign 'chunks' of rows such that the sum of associated weights is equal on each partition.

The row_weights vector is required to have the same size and distribution as the row-map of input_matrix.

Teuchos::RefCountPtr<Epetra_CrsMatrix> create_balanced_copy (  const Epetra_RowMatrix &  input_matrix,
const Epetra_Vector &  row_weights
) 
 

Create a balanced copy of an input Epetra_RowMatrix, accounting for user-supplied weights assigned to each row.

This function uses a self-contained internal implementation rather than interfacing to a third-party library such as Zoltan.

The rebalancing is 1-D, row-wise, and attempts to assign 'chunks' of rows such that the sum of associated weights is equal on each partition.

The row_weights vector is required to have the same size and distribution as the row-map of input_matrix.

Teuchos::RefCountPtr<Epetra_CrsGraph> create_balanced_copy (  const Epetra_CrsGraph &  input_graph,
Teuchos::ParameterList &  paramlist
) 
 

Create a balanced copy of an input Epetra_CrsGraph.

This function represents a basic case, not accepting weights.

If Isorropia was configured with Zoltan support, then Zoltan will be used as the underlying partitioner by default. Otherwise, the simple linear built-in partitioner will be used. Any parameters that are to be relayed through to Zoltan should be placed in a "Zoltan" sublist of the ParameterList. Refer to the Zoltan users guide for specific parameters that Zoltan recognizes. A couple of important ones are "LB_METHOD" (valid values include "GRAPH", "HYPERGRAPH"), "DEBUG_LEVEL" (valid values are 0 to 10, default is 1), etc.

The rebalancing is 1-D, row-wise, and attempts to make the number of nonzeros equal in each partition. I.e., it is equivalent to specifying a weighted rebalance where the weights are the number of nonzeros in each row.

Teuchos::RefCountPtr<Epetra_CrsGraph> create_balanced_copy (  const Epetra_CrsGraph &  input_graph,
const Epetra_Vector &  row_weights
) 
 

Create a balanced copy of an input Epetra_CrsGraph, accounting for user-supplied weights assigned to each row.

This function uses a self-contained internal implementation rather than interfacing to a third-party library such as Zoltan.

The rebalancing is 1-D, row-wise, and attempts to assign 'chunks' of rows such that the sum of associated weights is equal on each partition.

The row_weights vector is required to have the same size and distribution as the row-map of input_graph.

Teuchos::RefCountPtr<Epetra_LinearProblem> create_balanced_copy (  const Epetra_LinearProblem &  input_problem  ) 
 

Create a balanced copy of an input Epetra_LinearProblem.

This function represents the most basic default case, not accepting parameters or weights. If Isorropia was configured with Zoltan support, then Zoltan is used as the underlying partitioner by default. Otherwise the simple linear built-in partitioner is used.

The rebalancing is 1-D, row-wise, and attempts to make the number of nonzeros in the matrix equal in each partition. I.e., it is equivalent to specifying a weighted matrix rebalance where the weights are the number of nonzeros in each row. The vectors are then redistributed to match the row-distribution of the matrix.

Important note: It is the caller's responsibility to destroy the matrix and vector attributes of the returned Epetra_LinearProblem.

Teuchos::RefCountPtr<Epetra_CrsMatrix> redistribute_rows (  const Epetra_CrsMatrix &  input_matrix,
const Epetra_Map &  target_rowmap,
Epetra_Import *  importer = 0
) 
 

Return a new Epetra_CrsMatrix object constructed with target_rowmap, and with the contents of input_matrix imported into it.

The caller is responsible for deleting the returned object.

Parameters:
input_matrix Source/input object.
target_rowmap Target rowmap, required to be compatible with input_matrix.RowMap() in terms of number-of-elements, etc.
importer Optional argument. If importer is supplied, it will be used to perform the import operation. Otherwise, a temporary importer will be created and used.

Teuchos::RefCountPtr<Epetra_CrsMatrix> redistribute_rows (  const Epetra_RowMatrix &  input_matrix,
const Epetra_Map &  target_rowmap,
Epetra_Import *  importer = 0
) 
 

Return a new Epetra_CrsMatrix object constructed with target_rowmap, and with the contents of input_matrix imported into it.

The caller is responsible for deleting the returned object.

Parameters:
input_matrix Source/input object.
target_rowmap Target rowmap, required to be compatible with input_matrix.RowMatrixRowMap() in terms of number-of-elements, etc.
importer Optional argument. If importer is supplied, it will be used to perform the import operation. Otherwise, a temporary importer will be created and used.

Teuchos::RefCountPtr<Epetra_CrsGraph> redistribute_rows (  const Epetra_CrsGraph &  input_graph,
const Epetra_Map &  target_rowmap,
Epetra_Import *  importer = 0
) 
 

Return a new Epetra_CrsGraph object constructed with target_rowmap, and with the contents of input_graph imported into it.

Parameters:
input_graph Source/input object.
target_rowmap Target rowmap, required to be compatible with input_graph.RowMap() in terms of number-of-elements, etc.
importer Optional argument. If importer is supplied, it will be used to perform the import operation. Otherwise, a temporary importer will be created and used.

Teuchos::RefCountPtr<Epetra_MultiVector> redistribute (  const Epetra_MultiVector &  input,
const Epetra_BlockMap &  target_map,
Epetra_Import *  importer = 0
) 
 

Return a new Epetra_MultiVector object constructed with target_map, and with the contents of 'input' imported into it.

Parameters:
input Source/input object.
target_map Target map, required to be compatible with input.Map() in terms of number-of-elements, etc.
importer Optional argument. If importer is supplied, it will be used to perform the import operation. Otherwise, a temporary importer will be created and used.

Teuchos::RefCountPtr<Epetra_Vector> redistribute (  const Epetra_Vector &  input,
const Epetra_Map &  target_map,
Epetra_Import *  importer = 0
) 
 

Return a new Epetra_Vector object constructed with target_map, and with the contents of 'input' imported into it.

Parameters:
input Source/input object.
target_map Target map, required to be compatible with input.RowMap() in terms of number-of-elements, etc.
importer Optional argument. If importer is supplied, it will be used to perform the import operation. Otherwise, a temporary importer will be created and used.