// Constructor - creates the Epetra objects (maps and vectors) Interface::Interface(int numGlobalElements, Epetra_Comm& comm, double xmin_, double xmax_) : NumGlobalElements(numGlobalElements), NumMyElements(0), // gets set after map creation MyPID(comm.MyPID()), NumProc(comm.NumProc()), xmin(xmin_), xmax(xmax_), factor(1.0), Comm(&comm), StandardMap(0), OverlapMap(0), Importer(0), rhs(0), Graph(0) { // Construct a Source Map that puts approximately the same // Number of equations on each processor in uniform global ordering StandardMap = new Epetra_Map(NumGlobalElements, 0, *Comm); // Get the number of elements owned by this processor NumMyElements = StandardMap->NumMyElements(); // Construct an overlaped map for the finite element fill ************* // For single processor jobs, the overlap and standard map are the same if (NumProc == 1) { OverlapMap = new Epetra_Map(*StandardMap); } else { int OverlapNumMyElements; int OverlapMinMyGID; OverlapNumMyElements = NumMyElements + 2; if ((MyPID == 0) || (MyPID == NumProc - 1)) OverlapNumMyElements --; if (MyPID==0) OverlapMinMyGID = StandardMap->MinMyGID(); else OverlapMinMyGID = StandardMap->MinMyGID() - 1; int* OverlapMyGlobalElements = new int[OverlapNumMyElements]; for (int i = 0; i < OverlapNumMyElements; i ++) OverlapMyGlobalElements[i] = OverlapMinMyGID + i; OverlapMap = new Epetra_Map(-1, OverlapNumMyElements, OverlapMyGlobalElements, 0, *Comm); delete [] OverlapMyGlobalElements; } // End Overlap map construction ************************************* // Construct Linear Objects Importer = new Epetra_Import(*OverlapMap, *StandardMap); initialSolution = Teuchos::rcp(new Epetra_Vector(*StandardMap)); // Assign non-zero entries in the graph createGraph(); // Construct a matrix jacobian = Teuchos::rcp(new Epetra_CrsMatrix (Copy, *Graph)); // Clean-up jacobian->FillComplete(); // Create the nodal coordinates xptr = Teuchos::rcp(new Epetra_Vector(*StandardMap)); double Length = xmax - xmin; double dx = Length/((double) NumGlobalElements-1); for (int i=0; i < NumMyElements; i++) { (*xptr)[i] = xmin + dx*((double) StandardMap->MinMyGID()+i); } initializeSoln(); }
// Constructor - creates the Epetra objects (maps and vectors) Brusselator::Brusselator(int numGlobalNodes, Epetra_Comm& comm, OverlapType OType_) : xmin(0.0), xmax(1.0), Comm(&comm), overlapType(OType_), NumGlobalNodes(numGlobalNodes), ColumnToOverlapImporter(0), AA(0), A(0), alpha(0.6), beta(2.0) { // Commonly used variables int i; MyPID = Comm->MyPID(); // Process ID NumProc = Comm->NumProc(); // Total number of processes // Here we assume a 2-species Brusselator model, ie 2 dofs per node // Note that this needs to be echoed in thew anonymous enum for NUMSPECIES. NumSpecies = 2; NumGlobalUnknowns = NumSpecies * NumGlobalNodes; // Construct a Source Map that puts approximately the same // number of equations on each processor // Begin by distributing nodes fairly equally StandardNodeMap = new Epetra_Map(NumGlobalNodes, 0, *Comm); // Get the number of nodes owned by this processor NumMyNodes = StandardNodeMap->NumMyElements(); // Construct an overlap node map for the finite element fill // For single processor jobs, the overlap and standard maps are the same if (NumProc == 1) OverlapNodeMap = new Epetra_Map(*StandardNodeMap); else { if( overlapType == ELEMENTS ) { int OverlapNumMyNodes; int OverlapMinMyNodeGID; OverlapNumMyNodes = NumMyNodes + 2; if ((MyPID == 0) || (MyPID == NumProc - 1)) OverlapNumMyNodes --; if (MyPID==0) OverlapMinMyNodeGID = StandardNodeMap->MinMyGID(); else OverlapMinMyNodeGID = StandardNodeMap->MinMyGID() - 1; int* OverlapMyGlobalNodes = new int[OverlapNumMyNodes]; for (i = 0; i < OverlapNumMyNodes; i ++) OverlapMyGlobalNodes[i] = OverlapMinMyNodeGID + i; OverlapNodeMap = new Epetra_Map(-1, OverlapNumMyNodes, OverlapMyGlobalNodes, 0, *Comm); delete [] OverlapMyGlobalNodes; } else { // overlapType == NODES // Here we distribute elements such that nodes are ghosted, i.e. no // overlapping elements but instead overlapping nodes int OverlapNumMyNodes; int OverlapMinMyNodeGID; OverlapNumMyNodes = NumMyNodes + 1; if ( MyPID == NumProc - 1 ) OverlapNumMyNodes --; OverlapMinMyNodeGID = StandardNodeMap->MinMyGID(); int* OverlapMyGlobalNodes = new int[OverlapNumMyNodes]; for (i = 0; i < OverlapNumMyNodes; i ++) OverlapMyGlobalNodes[i] = OverlapMinMyNodeGID + i; OverlapNodeMap = new Epetra_Map(-1, OverlapNumMyNodes, OverlapMyGlobalNodes, 0, *Comm); delete [] OverlapMyGlobalNodes; } } // End Overlap node map construction ******************************** // Now create the unknowns maps from the node maps NumMyUnknowns = NumSpecies * NumMyNodes; int* StandardMyGlobalUnknowns = new int[NumMyUnknowns]; for (int k=0; k<NumSpecies; k++) for (i=0; i<NumMyNodes; i++) // For now, we employ an interleave of unknowns StandardMyGlobalUnknowns[ NumSpecies * i + k ] = NumSpecies * StandardNodeMap->GID(i) + k; StandardMap = new Epetra_Map(-1, NumMyUnknowns, StandardMyGlobalUnknowns, 0, *Comm); delete [] StandardMyGlobalUnknowns; assert(StandardMap->NumGlobalElements() == NumGlobalUnknowns); if (NumProc == 1) { OverlapMap = new Epetra_Map(*StandardMap); } else { int OverlapNumMyNodes = OverlapNodeMap->NumMyElements(); int OverlapNumMyUnknowns = NumSpecies * OverlapNumMyNodes; int* OverlapMyGlobalUnknowns = new int[OverlapNumMyUnknowns]; for (int k=0; k<NumSpecies; k++) for (i=0; i<OverlapNumMyNodes; i++) OverlapMyGlobalUnknowns[ NumSpecies * i + k ] = NumSpecies * OverlapNodeMap->GID(i) + k; OverlapMap = new Epetra_Map(-1, OverlapNumMyUnknowns, OverlapMyGlobalUnknowns, 0, *Comm); delete [] OverlapMyGlobalUnknowns; } // End Overlap unknowns map construction *************************** #ifdef DEBUG_MAPS // Output to check progress so far printf("[%d] NumSpecies, NumMyNodes, NumGlobalNodes, NumMyUnknowns, NumGlobalUnknowns :\n %d\t%d\t%d\t%d\n", MyPID,NumSpecies, NumMyNodes, NumGlobalNodes, NumMyUnknowns, NumGlobalUnknowns); Comm->Barrier(); Comm->Barrier(); Comm->Barrier(); printf("[%d] StandardNodeMap :\n", MyPID); Comm->Barrier(); cout << *StandardNodeMap << endl; Comm->Barrier(); printf("[%d] OverlapNodeMap :\n", MyPID); Comm->Barrier(); cout << *OverlapNodeMap << endl; Comm->Barrier(); printf("[%d] StandardMap :\n", MyPID); Comm->Barrier(); cout << *StandardMap << endl; Comm->Barrier(); printf("[%d] StandardMap :\n", MyPID); Comm->Barrier(); cout << *OverlapMap << endl; Comm->Barrier(); #endif // Construct Linear Objects Importer = new Epetra_Import(*OverlapMap, *StandardMap); nodeImporter = new Epetra_Import(*OverlapNodeMap, *StandardNodeMap); initialSolution = new Epetra_Vector(*StandardMap); solnDot = new Epetra_Vector(*StandardMap); AA = new Epetra_CrsGraph(Copy, *StandardMap, 0); // Allocate the memory for a matrix dynamically (i.e. the graph is dynamic). if( overlapType == NODES ) generateGraphUsingNodes(*AA); else generateGraphUsingElements(*AA); #ifdef DEBUG_GRAPH AA->Print(cout); #endif #ifdef DEBUG_IMPORTER Importer->Print(cout); #endif // Create the Importer needed for FD coloring using element overlap // as well as the problem Jacobian matrix which may or may not be used // depending on the choice of Jacobian operator if( overlapType == ELEMENTS ) { ColumnToOverlapImporter = new Epetra_Import(AA->ColMap(),*OverlapMap); A = new Epetra_CrsMatrix (Copy, *AA); A->FillComplete(); } // Create the nodal coordinates xptr = new Epetra_Vector(*StandardNodeMap); double Length= xmax - xmin; dx=Length/((double) NumGlobalNodes-1); for (i=0; i < NumMyNodes; i++) { (*xptr)[i]=xmin + dx*((double) StandardNodeMap->MinMyGID()+i); } initializeSoln(); }
// Constructor - creates the Epetra objects (maps and vectors) PelletTransport::PelletTransport( int NumGlobalElementsUO2_ , double xminUO2_ , double xmaxUO2_ , int NumGlobalElementsHe_ , double xminHe_ , double xmaxHe_ , int NumGlobalElementsClad_ , double xminClad_ , double xmaxClad_ , Epetra_Comm& Comm_, bool restart_ ) : NumGlobalElementsUO2(NumGlobalElementsUO2_), NumGlobalElementsHe(NumGlobalElementsHe_), NumGlobalElementsClad(NumGlobalElementsClad_), xminUO2(xminUO2_), xmaxUO2(xmaxUO2_), xminHe(xminHe_), xmaxHe(xmaxHe_), xminClad(xminClad_), xmaxClad(xmaxClad_), dt(1.0e+10), restart(restart_), Comm(&Comm_) { NumGlobalNodes = NumGlobalElementsUO2 + NumGlobalElementsHe + NumGlobalElementsClad + 1; MyPID = Comm->MyPID(); // Process ID NumProc = Comm->NumProc(); // Total number of processes // Here we assume a 2-species PelletTransport model, ie 2 dofs per node // Note that this needs to be echoed in thew anonymous enum for NUMSPECIES. NumSpecies = 2; NumGlobalUnknowns = NumSpecies * NumGlobalNodes; // Construct a Source Map that puts approximately the same // number of equations on each processor // Begin by distributing nodes fairly equally StandardNodeMap = new Epetra_Map(NumGlobalNodes, 0, *Comm); // Get the number of nodes owned by this processor NumMyNodes = StandardNodeMap->NumMyElements(); // Construct an overlap node map for the finite element fill // For single processor jobs, the overlap and standard maps are the same if (NumProc == 1) OverlapNodeMap = new Epetra_Map(*StandardNodeMap); else { // Distribute elements such that nodes are ghosted int OverlapNumMyNodes; int OverlapMinMyNodeGID; OverlapNumMyNodes = NumMyNodes + 1; if ( MyPID == NumProc - 1 ) OverlapNumMyNodes --; OverlapMinMyNodeGID = StandardNodeMap->MinMyGID(); int* OverlapMyGlobalNodes = new int[OverlapNumMyNodes]; for( int i = 0; i < OverlapNumMyNodes; ++i ) OverlapMyGlobalNodes[i] = OverlapMinMyNodeGID + i; OverlapNodeMap = new Epetra_Map(-1, OverlapNumMyNodes, OverlapMyGlobalNodes, 0, *Comm); delete [] OverlapMyGlobalNodes; } // End Overlap node map construction ******************************** // Now create the unknowns maps from the node maps NumMyUnknowns = NumSpecies * NumMyNodes; int* StandardMyGlobalUnknowns = new int[NumMyUnknowns]; for( int k = 0; k < NumSpecies; ++k ) for( int i = 0; i < NumMyNodes; ++i ) { // For now, we employ an interleave of unknowns StandardMyGlobalUnknowns[ NumSpecies * i + k ] = NumSpecies * StandardNodeMap->GID(i) + k; } StandardMap = new Epetra_Map(-1, NumMyUnknowns, StandardMyGlobalUnknowns, 0, *Comm); delete [] StandardMyGlobalUnknowns; assert(StandardMap->NumGlobalElements() == NumGlobalUnknowns); if (NumProc == 1) OverlapMap = new Epetra_Map(*StandardMap); else { int OverlapNumMyNodes = OverlapNodeMap->NumMyElements(); int OverlapNumMyUnknowns = NumSpecies * OverlapNumMyNodes; int* OverlapMyGlobalUnknowns = new int[OverlapNumMyUnknowns]; for (int k=0; k<NumSpecies; k++) for( int i = 0; i < OverlapNumMyNodes; ++i ) OverlapMyGlobalUnknowns[ NumSpecies * i + k ] = NumSpecies * OverlapNodeMap->GID(i) + k; OverlapMap = new Epetra_Map(-1, OverlapNumMyUnknowns, OverlapMyGlobalUnknowns, 0, *Comm); delete [] OverlapMyGlobalUnknowns; } // End Overlap unknowns map construction *************************** #ifdef DEBUG_MAPS // Output to check progress so far printf("[%d] NumSpecies, NumMyNodes, NumGlobalNodes, NumMyUnknowns, NumGlobalUnknowns :\n %d\t%d\t%d\t%d\n", MyPID,NumSpecies, NumMyNodes, NumGlobalNodes, NumMyUnknowns, NumGlobalUnknowns); Comm->Barrier(); Comm->Barrier(); Comm->Barrier(); printf("[%d] StandardNodeMap :\n", MyPID); Comm->Barrier(); cout << *StandardNodeMap << endl; Comm->Barrier(); printf("[%d] OverlapNodeMap :\n", MyPID); Comm->Barrier(); cout << *OverlapNodeMap << endl; Comm->Barrier(); printf("[%d] StandardMap :\n", MyPID); Comm->Barrier(); cout << *StandardMap << endl; Comm->Barrier(); printf("[%d] StandardMap :\n", MyPID); Comm->Barrier(); cout << *OverlapMap << endl; Comm->Barrier(); #endif // Construct Linear Objects Importer = new Epetra_Import(*OverlapMap, *StandardMap); nodeImporter = new Epetra_Import(*OverlapNodeMap, *StandardNodeMap); initialSolution = Teuchos::rcp(new Epetra_Vector(*StandardMap)); oldSolution = new Epetra_Vector(*StandardMap); AA = Teuchos::rcp(new Epetra_CrsGraph(Copy, *StandardMap, 0)); // Allocate the memory for a matrix dynamically (i.e. the graph is dynamic). generateGraphUsingNodes(*AA); #ifdef DEBUG_GRAPH AA->Print(cout); #endif #ifdef DEBUG_IMPORTER Importer->Print(cout); #endif // Create the element type int vector int numLocalElems = OverlapNodeMap->NumMyElements() - 1; Epetra_Map * elemMap = new Epetra_Map(-1, numLocalElems, 0, *Comm); elemTypes = Teuchos::rcp(new Epetra_IntVector(*elemMap)); for( int i = 0; i < numLocalElems; ++i ) if( i < NumGlobalElementsUO2 ) (*elemTypes)[i] = UO2; else if( i < (NumGlobalElementsUO2 + NumGlobalElementsHe) ) (*elemTypes)[i] = HELIUM; //(*elemTypes)[i] = UO2; else (*elemTypes)[i] = CLAD; //(*elemTypes)[i] = UO2; delete elemMap; // Create the nodal coordinates - only works in serial for now - RWH xptr = Teuchos::rcp(new Epetra_Vector(*StandardNodeMap)); int inode = 0; double length = xmaxUO2 - xminUO2; double dx = length/((double) NumGlobalElementsUO2 ); (*xptr)[inode++] = xminUO2; for( int i = 1; i < NumGlobalElementsUO2; ++i ) { (*xptr)[inode] = (*xptr)[inode-1] + dx; inode++; } length = xmaxHe - xminHe; dx = length/((double) NumGlobalElementsHe ); (*xptr)[inode++] = xminHe; for( int i = 1; i < NumGlobalElementsHe; ++i ) { (*xptr)[inode] = (*xptr)[inode-1] + dx; inode++; } length = xmaxClad - xminClad; dx = length/((double) NumGlobalElementsClad ); (*xptr)[inode++] = xminClad; for( int i = 0; i < NumGlobalElementsClad; ++i ) { (*xptr)[inode] = (*xptr)[inode-1] + dx; inode++; } initializeSoln(); }
// Constructor - creates the Epetra objects (maps and vectors) Brusselator::Brusselator(int numGlobalNodes, Epetra_Comm& comm) : xmin(0.0), xmax(1.0), Comm(&comm), NumGlobalNodes(numGlobalNodes), ColumnToOverlapImporter(0), AA(0), A(0), alpha(0.25), beta(1.5), D1(1.0/40.0), D2(1.0/40.0) { // Commonly used variables int i; MyPID = Comm->MyPID(); // Process ID NumProc = Comm->NumProc(); // Total number of processes // Here we assume a 2-species Brusselator model, ie 2 dofs per node // Note that this needs to be echoed in thew anonymous enum for NUMSPECIES. NumSpecies = 2; NumGlobalUnknowns = NumSpecies * NumGlobalNodes; // Construct a Source Map that puts approximately the same // number of equations on each processor // Begin by distributing nodes fairly equally StandardNodeMap = new Epetra_Map(NumGlobalNodes, 0, *Comm); // Get the number of nodes owned by this processor NumMyNodes = StandardNodeMap->NumMyElements(); // Construct an overlap node map for the finite element fill // For single processor jobs, the overlap and standard maps are the same if (NumProc == 1) OverlapNodeMap = new Epetra_Map(*StandardNodeMap); else { int OverlapNumMyNodes; int OverlapMinMyNodeGID; OverlapNumMyNodes = NumMyNodes + 2; if ((MyPID == 0) || (MyPID == NumProc - 1)) OverlapNumMyNodes --; if (MyPID==0) OverlapMinMyNodeGID = StandardNodeMap->MinMyGID(); else OverlapMinMyNodeGID = StandardNodeMap->MinMyGID() - 1; int* OverlapMyGlobalNodes = new int[OverlapNumMyNodes]; for (i = 0; i < OverlapNumMyNodes; i ++) OverlapMyGlobalNodes[i] = OverlapMinMyNodeGID + i; OverlapNodeMap = new Epetra_Map(-1, OverlapNumMyNodes, OverlapMyGlobalNodes, 0, *Comm); delete [] OverlapMyGlobalNodes; } // End Overlap node map construction ******************************** // Now create the unknowns maps from the node maps NumMyUnknowns = NumSpecies * NumMyNodes; int* StandardMyGlobalUnknowns = new int[NumMyUnknowns]; for (int k=0; k<NumSpecies; k++) for (i=0; i<NumMyNodes; i++) { // For now, we employ an interleave of unknowns StandardMyGlobalUnknowns[ NumSpecies * i + k ] = NumSpecies * StandardNodeMap->GID(i) + k; } StandardMap = new Epetra_Map(-1, NumMyUnknowns, StandardMyGlobalUnknowns, 0, *Comm); delete [] StandardMyGlobalUnknowns; assert(StandardMap->NumGlobalElements() == NumGlobalUnknowns); if (NumProc == 1) { OverlapMap = new Epetra_Map(*StandardMap); } else { int OverlapNumMyNodes = OverlapNodeMap->NumMyElements(); int OverlapNumMyUnknowns = NumSpecies * OverlapNumMyNodes; int* OverlapMyGlobalUnknowns = new int[OverlapNumMyUnknowns]; for (int k=0; k<NumSpecies; k++) for (i=0; i<OverlapNumMyNodes; i++) OverlapMyGlobalUnknowns[ NumSpecies * i + k ] = NumSpecies * OverlapNodeMap->GID(i) + k; OverlapMap = new Epetra_Map(-1, OverlapNumMyUnknowns, OverlapMyGlobalUnknowns, 0, *Comm); delete [] OverlapMyGlobalUnknowns; } // End Overlap unknowns map construction *************************** // Construct Linear Objects Importer = new Epetra_Import(*OverlapMap, *StandardMap); nodeImporter = new Epetra_Import(*OverlapNodeMap, *StandardNodeMap); initialSolution = new Epetra_Vector(*StandardMap); AA = new Epetra_CrsGraph(Copy, *StandardMap, 0); // Allocate the memory for a matrix dynamically (i.e. the graph is dynamic). generateGraph(*AA); // Create the matrix A = new Epetra_CrsMatrix (Copy, *AA); A->FillComplete(); // Create the nodal coordinates xptr = new Epetra_Vector(*StandardNodeMap); double Length= xmax - xmin; dx=Length/((double) NumGlobalNodes-1); for (i=0; i < NumMyNodes; i++) { (*xptr)[i]=xmin + dx*((double) StandardNodeMap->MinMyGID()+i); } initializeSoln(); }