typename boost::disable_if< boost::is_same<T, Albany::AbstractSTKFieldContainer::ScalarFieldType>, void >::type
Albany::GenericSTKFieldContainer<Interleaved>::fillVectorHelper(Epetra_Vector& soln,
T* solution_field,
const Teuchos::RCP<Epetra_Map>& node_map,
const stk::mesh::Bucket& bucket, int offset) {
// Fill the result vector
// Create a multidimensional array view of the
// solution field data for this bucket of nodes.
// The array is two dimensional ( Cartesian X NumberNodes )
// and indexed by ( 0..2 , 0..NumberNodes-1 )
BucketArray<T> solution_array(*solution_field, bucket);
const int num_vec_components = solution_array.dimension(0);
const int num_nodes_in_bucket = solution_array.dimension(1);
stk::mesh::BulkData& mesh = solution_field->get_mesh();
for(std::size_t i = 0; i < num_nodes_in_bucket; i++) {
const GO node_gid = mesh.identifier(bucket[i]) - 1;
#ifdef ALBANY_64BIT_INT
int node_lid = node_map->LID(static_cast<long long int>(node_gid));
#else
// const unsigned node_gid = bucket[i].identifier();
int node_lid = node_map->LID(node_gid);
#endif
for(std::size_t j = 0; j < num_vec_components; j++)
soln[getDOF(node_lid, offset + j)] = solution_array(j, i);
}
}
void Albany::GenericSTKFieldContainer<Interleaved>::saveVectorHelper(const Epetra_Vector& soln,
ScalarFieldType* solution_field,
const Teuchos::RCP<Epetra_Map>& node_map,
const stk::mesh::Bucket& bucket, int offset) {
// Fill the result vector
// Create a multidimensional array view of the
// solution field data for this bucket of nodes.
// The array is two dimensional ( Cartesian X NumberNodes )
// and indexed by ( 0..2 , 0..NumberNodes-1 )
BucketArray<ScalarFieldType> solution_array(*solution_field, bucket);
const int num_nodes_in_bucket = solution_array.dimension(0);
stk::mesh::BulkData& mesh = solution_field->get_mesh();
for(std::size_t i = 0; i < num_nodes_in_bucket; i++) {
const GO node_gid = mesh.identifier(bucket[i]) - 1;
#ifdef ALBANY_64BIT_INT
int node_lid = node_map->LID(static_cast<long long int>(node_gid));
#else
int node_lid = node_map->LID(node_gid);
#endif
solution_array(i) = soln[getDOF(node_lid, offset)];
}
}
typename boost::disable_if< boost::is_same<T, Albany::AbstractSTKFieldContainer::ScalarFieldType>, void >::type
Albany::GenericSTKFieldContainer<Interleaved>::fillVectorHelper(
Epetra_Vector& field_vector, T* field, const Teuchos::RCP<Epetra_Map>& node_map,
const stk::mesh::Bucket& bucket, const NodalDOFManager& nodalDofManager, int offset) {
BucketArray<T> field_array(*field, bucket);
const int num_nodes_in_bucket = field_array.dimension(1);
stk::mesh::BulkData& mesh = field->get_mesh();
for(std::size_t i = 0; i < num_nodes_in_bucket; i++) {
// const unsigned node_gid = bucket[i].identifier();
const int node_gid = mesh.identifier(bucket[i]) - 1;
#ifdef ALBANY_64BIT_INT
int node_lid = node_map->LID(static_cast<long long int>(node_gid));
#else
int node_lid = node_map->LID(node_gid);
#endif
if(node_lid>=0)
for(std::size_t j = 0; j < (std::size_t)nodalDofManager.numComponents(); j++)
field_vector[nodalDofManager.getLocalDOF(node_lid,offset+j)] = field_array(j,i);
}
}
void
DirichletField<PHAL::AlbanyTraits::Residual, Traits>::
evaluateFields(typename Traits::EvalData dirichletWorkset) {
#if defined(ALBANY_EPETRA)
const Albany::NodalDOFManager& fieldDofManager = dirichletWorkset.disc->getDOFManager(this->field_name);
Teuchos::RCP<const Epetra_Map> fiedNodeMap = dirichletWorkset.disc->getNodeMap(this->field_name);
const std::vector<GO>& nsNodesGIDs = dirichletWorkset.disc->getNodeSetGIDs().find(this->nodeSetID)->second;
#endif
Teuchos::RCP<Tpetra_Vector> pvecT = dirichletWorkset.distParamLib->get(this->field_name)->vector();
Teuchos::ArrayRCP<const ST> pT = pvecT->get1dView();
Teuchos::RCP<Tpetra_Vector> fT = dirichletWorkset.fT;
Teuchos::RCP<const Tpetra_Vector> xT = dirichletWorkset.xT;
Teuchos::ArrayRCP<const ST> xT_constView = xT->get1dView();
Teuchos::ArrayRCP<ST> fT_nonconstView = fT->get1dViewNonConst();
const std::vector<std::vector<int> >& nsNodes = dirichletWorkset.nodeSets->find(this->nodeSetID)->second;
for (unsigned int inode = 0; inode < nsNodes.size(); inode++) {
int lunk = nsNodes[inode][this->offset];
#if defined(ALBANY_EPETRA)
GO node_gid = nsNodesGIDs[inode];
int lfield = fieldDofManager.getLocalDOF(fiedNodeMap->LID(node_gid),this->offset);
fT_nonconstView[lunk] = xT_constView[lunk] - pT[lfield];
#else
fT_nonconstView[lunk] = xT_constView[lunk] - pT[lunk];
#endif
}
}
void DirichletField<PHAL::AlbanyTraits::Tangent, Traits>::
evaluateFields(typename Traits::EvalData dirichletWorkset) {
#if defined(ALBANY_EPETRA)
const Albany::NodalDOFManager& fieldDofManager = dirichletWorkset.disc->getDOFManager(this->field_name);
Teuchos::RCP<const Epetra_Map> fiedNodeMap = dirichletWorkset.disc->getNodeMap(this->field_name);
const std::vector<GO>& nsNodesGIDs = dirichletWorkset.disc->getNodeSetGIDs().find(this->nodeSetID)->second;
#endif
Teuchos::RCP<Tpetra_Vector> pvecT = dirichletWorkset.distParamLib->get(this->field_name)->vector();
Teuchos::ArrayRCP<const ST> pT = pvecT->get1dView();
Teuchos::RCP<Tpetra_Vector> fT = dirichletWorkset.fT;
Teuchos::RCP<Tpetra_MultiVector> fpT = dirichletWorkset.fpT;
Teuchos::RCP<Tpetra_MultiVector> JVT = dirichletWorkset.JVT;
Teuchos::RCP<const Tpetra_Vector> xT = dirichletWorkset.xT;
Teuchos::RCP<const Tpetra_MultiVector> VxT = dirichletWorkset.VxT;
Teuchos::ArrayRCP<const ST> VxT_constView;
Teuchos::ArrayRCP<ST> fT_nonconstView;
if (fT != Teuchos::null) fT_nonconstView = fT->get1dViewNonConst();
Teuchos::ArrayRCP<const ST> xT_constView = xT->get1dView();
const RealType j_coeff = dirichletWorkset.j_coeff;
const std::vector<std::vector<int> >& nsNodes =
dirichletWorkset.nodeSets->find(this->nodeSetID)->second;
for (unsigned int inode = 0; inode < nsNodes.size(); inode++) {
int lunk = nsNodes[inode][this->offset];
if (fT != Teuchos::null) {
#if defined(ALBANY_EPETRA)
GO node_gid = nsNodesGIDs[inode];
int lfield = fieldDofManager.getLocalDOF(fiedNodeMap->LID(node_gid),this->offset);
fT_nonconstView[lunk] = xT_constView[lunk] - pT[lfield];
#else
fT_nonconstView[lunk] = xT_constView[lunk] - pT[lunk];
#endif
}
if (JVT != Teuchos::null) {
Teuchos::ArrayRCP<ST> JVT_nonconstView;
for (int i=0; i<dirichletWorkset.num_cols_x; i++) {
JVT_nonconstView = JVT->getDataNonConst(i);
VxT_constView = VxT->getData(i);
JVT_nonconstView[lunk] = j_coeff*VxT_constView[lunk];
}
}
if (fpT != Teuchos::null) {
Teuchos::ArrayRCP<ST> fpT_nonconstView;
for (int i=0; i<dirichletWorkset.num_cols_p; i++) {
fpT_nonconstView = fpT->getDataNonConst(i);
fpT_nonconstView[lunk] = 0;
}
}
}
}
void DirichletField<PHAL::AlbanyTraits::Jacobian, Traits>::
evaluateFields(typename Traits::EvalData dirichletWorkset) {
#if defined(ALBANY_EPETRA)
const Albany::NodalDOFManager& fieldDofManager = dirichletWorkset.disc->getDOFManager(this->field_name);
Teuchos::RCP<const Epetra_Map> fiedNodeMap = dirichletWorkset.disc->getNodeMap(this->field_name);
const std::vector<GO>& nsNodesGIDs = dirichletWorkset.disc->getNodeSetGIDs().find(this->nodeSetID)->second;
#endif
Teuchos::RCP<Tpetra_Vector> pvecT = dirichletWorkset.distParamLib->get(this->field_name)->vector();
Teuchos::ArrayRCP<const ST> pT = pvecT->get1dView();
Teuchos::RCP<Tpetra_Vector> fT = dirichletWorkset.fT;
Teuchos::RCP<const Tpetra_Vector> xT = dirichletWorkset.xT;
Teuchos::ArrayRCP<const ST> xT_constView = xT->get1dView();
Teuchos::RCP<Tpetra_CrsMatrix> jacT = dirichletWorkset.JacT;
const RealType j_coeff = dirichletWorkset.j_coeff;
const std::vector<std::vector<int> >& nsNodes = dirichletWorkset.nodeSets->find(this->nodeSetID)->second;
bool fillResid = (fT != Teuchos::null);
Teuchos::ArrayRCP<ST> fT_nonconstView;
if (fillResid) fT_nonconstView = fT->get1dViewNonConst();
Teuchos::Array<LO> index(1);
Teuchos::Array<ST> value(1);
size_t numEntriesT;
value[0] = j_coeff;
Teuchos::Array<ST> matrixEntriesT;
Teuchos::Array<LO> matrixIndicesT;
for (unsigned int inode = 0; inode < nsNodes.size(); inode++) {
int lunk = nsNodes[inode][this->offset];
index[0] = lunk;
numEntriesT = jacT->getNumEntriesInLocalRow(lunk);
matrixEntriesT.resize(numEntriesT);
matrixIndicesT.resize(numEntriesT);
jacT->getLocalRowCopy(lunk, matrixIndicesT(), matrixEntriesT(), numEntriesT);
for (int i=0; i<numEntriesT; i++) matrixEntriesT[i]=0;
jacT->replaceLocalValues(lunk, matrixIndicesT(), matrixEntriesT());
jacT->replaceLocalValues(lunk, index(), value());
if (fillResid) {
#if defined(ALBANY_EPETRA)
GO node_gid = nsNodesGIDs[inode];
int lfield = fieldDofManager.getLocalDOF(fiedNodeMap->LID(node_gid),this->offset);
fT_nonconstView[lunk] = xT_constView[lunk] - pT[lfield];
#else
fT_nonconstView[lunk] = xT_constView[lunk] - pT[lunk];
#endif
}
}
}
Teuchos::RCP<PeridigmNS::NeighborhoodData> PeridigmNS::Block::createNeighborhoodDataFromGlobalNeighborhoodData(Teuchos::RCP<const Epetra_BlockMap> globalOverlapScalarPointMap,
Teuchos::RCP<const PeridigmNS::NeighborhoodData> globalNeighborhoodData)
{
int numOwnedPoints = ownedScalarPointMap->NumMyElements();
int* ownedPointGlobalIDs = ownedScalarPointMap->MyGlobalElements();
vector<int> ownedIDs(numOwnedPoints);
vector<int> neighborhoodList;
vector<int> neighborhoodPtr(numOwnedPoints);
int* const globalNeighborhoodList = globalNeighborhoodData->NeighborhoodList();
int* const globalNeighborhoodPtr = globalNeighborhoodData->NeighborhoodPtr();
// Create the neighborhoodList and neighborhoodPtr for this block.
// All the IDs in the neighborhoodList and neighborhoodPtr are local IDs into
// the block-specific overlap map.
for(int i=0 ; i<numOwnedPoints ; ++i){
neighborhoodPtr[i] = (int)(neighborhoodList.size());
int globalID = ownedPointGlobalIDs[i];
ownedIDs[i] = overlapScalarPointMap->LID(globalID);
int globalNeighborhoodListIndex = globalNeighborhoodPtr[globalOverlapScalarPointMap->LID(globalID)];
int numNeighbors = globalNeighborhoodList[globalNeighborhoodListIndex++];
neighborhoodList.push_back(numNeighbors);
for(int j=0 ; j<numNeighbors ; ++j){
int globalNeighborID = globalOverlapScalarPointMap->GID(globalNeighborhoodList[globalNeighborhoodListIndex++]);
neighborhoodList.push_back( overlapScalarPointMap->LID(globalNeighborID) );
}
}
// create the NeighborhoodData for this block
Teuchos::RCP<PeridigmNS::NeighborhoodData> blockNeighborhoodData = Teuchos::rcp(new PeridigmNS::NeighborhoodData);
blockNeighborhoodData->SetNumOwned(ownedIDs.size());
if(ownedIDs.size() > 0){
memcpy(blockNeighborhoodData->OwnedIDs(),
&ownedIDs.at(0),
ownedIDs.size()*sizeof(int));
}
if(neighborhoodPtr.size() > 0){
memcpy(blockNeighborhoodData->NeighborhoodPtr(),
&neighborhoodPtr.at(0),
neighborhoodPtr.size()*sizeof(int));
}
blockNeighborhoodData->SetNeighborhoodListSize(neighborhoodList.size());
if(neighborhoodList.size() > 0){
memcpy(blockNeighborhoodData->NeighborhoodList(),
&neighborhoodList.at(0),
neighborhoodList.size()*sizeof(int));
}
return blockNeighborhoodData;
}
void Albany::GenericSTKFieldContainer<Interleaved>::fillVectorHelper(
Epetra_Vector& field_vector, ScalarFieldType* field, const Teuchos::RCP<Epetra_Map>& node_map,
const stk::mesh::Bucket& bucket, const NodalDOFManager& nodalDofManager, int offset) {
BucketArray<ScalarFieldType> field_array(*field, bucket);
const int num_nodes_in_bucket = field_array.dimension(0);
stk::mesh::BulkData& mesh = field->get_mesh();
for(std::size_t i = 0; i < num_nodes_in_bucket; i++) {
// const unsigned node_gid = bucket[i].identifier();
const int node_gid = mesh.identifier(bucket[i]) - 1;
#ifdef ALBANY_64BIT_INT
int node_lid = node_map->LID(static_cast<long long int>(node_gid));
#else
int node_lid = node_map->LID(node_gid);
#endif
if(node_lid>=0)
field_vector[nodalDofManager.getLocalDOF(node_lid,offset)] = field_array(i);
}
}
void Albany::GenericSTKFieldContainer<Interleaved>::saveVectorHelper(
const Epetra_Vector& field_vector, ScalarFieldType* field, const Teuchos::RCP<Epetra_Map>& field_node_map,
const stk::mesh::Bucket& bucket, const NodalDOFManager& nodalDofManager, int offset) {
BucketArray<ScalarFieldType> field_array(*field, bucket);
const int num_nodes_in_bucket = field_array.dimension(0);
stk::mesh::BulkData& mesh = field->get_mesh();
for(std::size_t i = 0; i < num_nodes_in_bucket; i++) {
// const unsigned node_gid = bucket[i].identifier();
const int node_gid = mesh.identifier(bucket[i]) - 1;
int node_lid = field_node_map->LID(node_gid);
if(node_lid>=0)
field_array(i)=field_vector[nodalDofManager.getLocalDOF(node_lid,offset)];
}
}
// The solve is done in the felix_driver_run function, and the solution is passed back to Glimmer-CISM
// IK, 12/3/13: time_inc_yr and cur_time_yr are not used here...
void felix_driver_run(FelixToGlimmer * ftg_ptr, double& cur_time_yr, double time_inc_yr)
{
//IK, 12/9/13: how come FancyOStream prints an all processors??
Teuchos::RCP<Teuchos::FancyOStream> out(Teuchos::VerboseObjectBase::getDefaultOStream());
if (debug_output_verbosity != 0 & mpiCommT->getRank() == 0) {
std::cout << "In felix_driver_run, cur_time, time_inc = " << cur_time_yr
<< " " << time_inc_yr << std::endl;
}
// ---------------------------------------------
// get u and v velocity solution from Glimmer-CISM
// IK, 11/26/13: need to concatenate these into a single solve for initial condition for Albany/FELIX solve
// IK, 3/14/14: moved this step to felix_driver_run from felix_driver init, since we still want to grab and u and v velocities for CISM if the mesh hasn't changed,
// in which case only felix_driver_run will be called, not felix_driver_init.
// ---------------------------------------------
if (debug_output_verbosity != 0 & mpiCommT->getRank() == 0)
std::cout << "In felix_driver_run: grabbing pointers to u and v velocities in CISM..." << std::endl;
uVel_ptr = ftg_ptr ->getDoubleVar("uvel", "velocity");
vVel_ptr = ftg_ptr ->getDoubleVar("vvel", "velocity");
// ---------------------------------------------
// Set restart solution to the one passed from CISM
// IK, 3/14/14: moved this from felix_driver_init to felix_driver_run.
// ---------------------------------------------
if (debug_output_verbosity != 0 & mpiCommT->getRank() == 0)
std::cout << "In felix_driver_run: setting initial condition from CISM..." << std::endl;
//Check what kind of ordering you have in the solution & create solutionField object.
interleavedOrdering = meshStruct->getInterleavedOrdering();
Albany::AbstractSTKFieldContainer::VectorFieldType* solutionField;
if(interleavedOrdering)
solutionField = Teuchos::rcp_dynamic_cast<Albany::OrdinarySTKFieldContainer<true> >(meshStruct->getFieldContainer())->getSolutionField();
else
solutionField = Teuchos::rcp_dynamic_cast<Albany::OrdinarySTKFieldContainer<false> >(meshStruct->getFieldContainer())->getSolutionField();
//Create vector used to renumber nodes on each processor from the Albany convention (horizontal levels first) to the CISM convention (vertical layers first)
nNodes2D = (global_ewn + 1)*(global_nsn+1); //number global nodes in the domain in 2D
nNodesProc2D = (nsn-2*nhalo+1)*(ewn-2*nhalo+1); //number of nodes on each processor in 2D
cismToAlbanyNodeNumberMap.resize(upn*nNodesProc2D);
for (int j=0; j<nsn-2*nhalo+1;j++) {
for (int i=0; i<ewn-2*nhalo+1; i++) {
for (int k=0; k<upn; k++) {
int index = k+upn*i + j*(ewn-2*nhalo+1)*upn;
cismToAlbanyNodeNumberMap[index] = k*nNodes2D + global_node_id_owned_map_Ptr[i+j*(ewn-2*nhalo+1)];
//if (mpiComm->MyPID() == 0)
// std::cout << "index: " << index << ", cismToAlbanyNodeNumberMap: " << cismToAlbanyNodeNumberMap[index] << std::endl;
}
}
}
//The way it worked out, uVel_ptr and vVel_ptr have more nodes than the nodes in the mesh passed to Albany/CISM for the solve. In particular,
//there is 1 row of halo elements in uVel_ptr and vVel_ptr. To account for this, we copy uVel_ptr and vVel_ptr into std::vectors, which do not have the halo elements.
std::vector<double> uvel_vec(upn*nNodesProc2D);
std::vector<double> vvel_vec(upn*nNodesProc2D);
int counter1 = 0;
int counter2 = 0;
int local_nodeID;
for (int j=0; j<nsn-1; j++) {
for (int i=0; i<ewn-1; i++) {
for (int k=0; k<upn; k++) {
if (j >= nhalo-1 & j < nsn-nhalo) {
if (i >= nhalo-1 & i < ewn-nhalo) {
#ifdef CISM_USE_EPETRA
local_nodeID = node_map->LID(cismToAlbanyNodeNumberMap[counter1]);
#else
local_nodeID = node_map->getLocalElement(cismToAlbanyNodeNumberMap[counter1]);
#endif
uvel_vec[counter1] = uVel_ptr[counter2];
vvel_vec[counter1] = vVel_ptr[counter2];
counter1++;
}
}
counter2++;
}
}
}
//Loop over all the elements to find which nodes are active. For the active nodes, copy uvel and vvel from CISM into Albany solution array to
//use as initial condition.
//NOTE: there is some inefficiency here by looping over all the elements. TO DO? pass only active nodes from Albany-CISM to improve this?
double velScale = seconds_per_year*vel_scaling_param;
for (int i=0; i<nElementsActive; i++) {
for (int j=0; j<8; j++) {
int node_GID = global_element_conn_active_Ptr[i + nElementsActive*j]; //node_GID is 1-based
#ifdef CISM_USE_EPETRA
int node_LID = node_map->LID(node_GID); //node_LID is 0-based
#else
int node_LID = node_map->getLocalElement(node_GID); //node_LID is 0-based
#endif
stk::mesh::Entity node = meshStruct->bulkData->get_entity(stk::topology::NODE_RANK, node_GID);
double* sol = stk::mesh::field_data(*solutionField, node);
//IK, 3/18/14: added division by velScale to convert uvel and vvel from dimensionless to having units of m/year (the Albany units)
sol[0] = uvel_vec[node_LID]/velScale;
sol[1] = vvel_vec[node_LID]/velScale;
}
}
// ---------------------------------------------------------------------------------------------------
// Solve
// ---------------------------------------------------------------------------------------------------
if (debug_output_verbosity != 0 & mpiCommT->getRank() == 0)
std::cout << "In felix_driver_run: starting the solve... " << std::endl;
//Need to set HasRestart solution such that uvel_Ptr and vvel_Ptr (u and v from Glimmer/CISM) are always set as initial condition?
meshStruct->setHasRestartSolution(!first_time_step);
//Turn off homotopy if we're not in the first time-step.
//NOTE - IMPORTANT: Glen's Law Homotopy parameter should be set to 1.0 in the parameter list for this logic to work!!!
if (!first_time_step)
{
meshStruct->setRestartDataTime(parameterList->sublist("Problem").get("Homotopy Restart Step", 1.));
double homotopy = parameterList->sublist("Problem").sublist("FELIX Viscosity").get("Glen's Law Homotopy Parameter", 1.0);
if(meshStruct->restartDataTime()== homotopy) {
parameterList->sublist("Problem").set("Solution Method", "Steady");
parameterList->sublist("Piro").set("Solver Type", "NOX");
}
}
albanyApp->createDiscretization();
//IK, 10/30/14: Check that # of elements from previous time step hasn't changed.
//If it has not, use previous solution as initial guess for current time step.
//Otherwise do not set initial solution. It's possible this can be improved so some part of the previous solution is used
//defined on the current mesh (if it receded, which likely it will in dynamic ice sheet simulations...).
if (nElementsActivePrevious != nElementsActive) previousSolution = Teuchos::null;
albanyApp->finalSetUp(parameterList, previousSolution);
//if (!first_time_step)
// std::cout << "previousSolution: " << *previousSolution << std::endl;
#ifdef CISM_USE_EPETRA
solver = slvrfctry->createThyraSolverAndGetAlbanyApp(albanyApp, mpiComm, mpiComm, Teuchos::null, false);
#else
solver = slvrfctry->createAndGetAlbanyAppT(albanyApp, mpiCommT, mpiCommT, Teuchos::null, false);
#endif
Teuchos::ParameterList solveParams;
solveParams.set("Compute Sensitivities", true);
Teuchos::Array<Teuchos::RCP<const Thyra::VectorBase<double> > > thyraResponses;
Teuchos::Array<Teuchos::Array<Teuchos::RCP<const Thyra::MultiVectorBase<double> > > > thyraSensitivities;
Piro::PerformSolveBase(*solver, solveParams, thyraResponses, thyraSensitivities);
#ifdef CISM_USE_EPETRA
const Epetra_Map& ownedMap(*albanyApp->getDiscretization()->getMap()); //owned map
const Epetra_Map& overlapMap(*albanyApp->getDiscretization()->getOverlapMap()); //overlap map
Epetra_Import import(overlapMap, ownedMap); //importer from ownedMap to overlapMap
Epetra_Vector solutionOverlap(overlapMap); //overlapped solution
solutionOverlap.Import(*albanyApp->getDiscretization()->getSolutionField(), import, Insert);
#else
Teuchos::RCP<const Tpetra_Map> ownedMap = albanyApp->getDiscretization()->getMapT(); //owned map
Teuchos::RCP<const Tpetra_Map> overlapMap = albanyApp->getDiscretization()->getOverlapMapT(); //overlap map
Teuchos::RCP<Tpetra_Import> import = Teuchos::rcp(new Tpetra_Import(ownedMap, overlapMap));
Teuchos::RCP<Tpetra_Vector> solutionOverlap = Teuchos::rcp(new Tpetra_Vector(overlapMap));
solutionOverlap->doImport(*albanyApp->getDiscretization()->getSolutionFieldT(), *import, Tpetra::INSERT);
Teuchos::ArrayRCP<const ST> solutionOverlap_constView = solutionOverlap->get1dView();
#endif
#ifdef WRITE_TO_MATRIX_MARKET
#ifdef CISM_USE_EPETRA
//For debug: write solution and maps to matrix market file
EpetraExt::BlockMapToMatrixMarketFile("node_map.mm", *node_map);
EpetraExt::BlockMapToMatrixMarketFile("map.mm", ownedMap);
EpetraExt::BlockMapToMatrixMarketFile("overlap_map.mm", overlapMap);
EpetraExt::MultiVectorToMatrixMarketFile("solution.mm", *albanyApp->getDiscretization()->getSolutionField());
#else
Tpetra_MatrixMarket_Writer::writeMapFile("node_map.mm", *node_map);
Tpetra_MatrixMarket_Writer::writeMapFile("map.mm", *ownedMap);
Tpetra_MatrixMarket_Writer::writeMapFile("overlap_map.mm", *overlapMap);
Tpetra_MatrixMarket_Writer::writeDenseFile("solution.mm", app->getDiscretization()->getSolutionFieldT());
#endif
#endif
//set previousSolution (used as initial guess for next time step) to final Albany solution.
previousSolution = Teuchos::rcp(new Tpetra_Vector(*albanyApp->getDiscretization()->getSolutionFieldT()));
nElementsActivePrevious = nElementsActive;
//std::cout << "Final solution: " << *albanyApp->getDiscretization()->getSolutionField() << std::endl;
// ---------------------------------------------------------------------------------------------------
// Compute sensitivies / responses and perform regression tests
// IK, 12/9/13: how come this is turned off in mpas branch?
// ---------------------------------------------------------------------------------------------------
if (debug_output_verbosity != 0 & mpiCommT->getRank() == 0)
std::cout << "Computing responses and sensitivities..." << std::endl;
int status=0; // 0 = pass, failures are incremented
#ifdef CISM_USE_EPETRA
Teuchos::Array<Teuchos::RCP<const Epetra_Vector> > responses;
Teuchos::Array<Teuchos::Array<Teuchos::RCP<const Epetra_MultiVector> > > sensitivities;
epetraFromThyra(mpiComm, thyraResponses, thyraSensitivities, responses, sensitivities);
#else
Teuchos::Array<Teuchos::RCP<const Tpetra_Vector> > responses;
Teuchos::Array<Teuchos::Array<Teuchos::RCP<const Tpetra_MultiVector> > > sensitivities;
tpetraFromThyra(thyraResponses, thyraSensitivities, responses, sensitivities);
#endif
const int num_p = solver->Np(); // Number of *vectors* of parameters
const int num_g = solver->Ng(); // Number of *vectors* of responses
if (debug_output_verbosity != 0) {
*out << "Finished eval of first model: Params, Responses "
<< std::setprecision(12) << std::endl;
}
const Thyra::ModelEvaluatorBase::InArgs<double> nominal = solver->getNominalValues();
if (debug_output_verbosity != 0) {
for (int i=0; i<num_p; i++) {
#ifdef CISM_USE_EPETRA
const Teuchos::RCP<const Epetra_Vector> p_init = epetraVectorFromThyra(mpiComm, nominal.get_p(i));
p_init->Print(*out << "\nParameter vector " << i << ":\n");
#else
Albany::printTpetraVector(*out << "\nParameter vector " << i << ":\n",
ConverterT::getConstTpetraVector(nominal.get_p(i)));
#endif
}
}
for (int i=0; i<num_g-1; i++) {
#ifdef CISM_USE_EPETRA
const Teuchos::RCP<const Epetra_Vector> g = responses[i];
#else
const Teuchos::RCP<const Tpetra_Vector> g = responses[i];
#endif
bool is_scalar = true;
if (albanyApp != Teuchos::null)
is_scalar = albanyApp->getResponse(i)->isScalarResponse();
if (is_scalar) {
if (debug_output_verbosity != 0) {
#ifdef CISM_USE_EPETRA
g->Print(*out << "\nResponse vector " << i << ":\n");
#else
Albany::printTpetraVector(*out << "\nResponse vector " << i << ":\n", g);
#endif
}
if (num_p == 0 && cur_time_yr == final_time) {
// Just calculate regression data -- only if in final time step
#ifdef CISM_USE_EPETRA
status += slvrfctry->checkSolveTestResults(i, 0, g.get(), NULL);
#else
status += slvrfctry->checkSolveTestResultsT(i, 0, g.get(), NULL);
#endif
} else {
for (int j=0; j<num_p; j++) {
#ifdef CISM_USE_EPETRA
const Teuchos::RCP<const Epetra_MultiVector> dgdp = sensitivities[i][j];
#else
const Teuchos::RCP<const Tpetra_MultiVector> dgdp = sensitivities[i][j];
#endif
if (debug_output_verbosity != 0) {
if (Teuchos::nonnull(dgdp)) {
#ifdef CISM_USE_EPETRA
dgdp->Print(*out << "\nSensitivities (" << i << "," << j << "):!\n");
#else
Albany::printTpetraVector(*out << "\nSensitivities (" << i << "," << j << "):!\n", dgdp);
#endif
}
}
if (cur_time_yr == final_time) {
#ifdef CISM_USE_EPETRA
status += slvrfctry->checkSolveTestResults(i, j, g.get(), dgdp.get());
#else
status += slvrfctry->checkSolveTestResultsT(i, j, g.get(), dgdp.get());
#endif
}
}
}
}
}
if (debug_output_verbosity != 0 && cur_time_yr == final_time) //only print regression test result if you're in the final time step
*out << "\nNumber of Failed Comparisons: " << status << std::endl;
//IK, 10/30/14: added the following line so that when you run ctest from CISM the test fails if there are some failed comparisons.
if (status > 0)
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "All regression comparisons did not pass!" << std::endl);
// ---------------------------------------------------------------------------------------------------
// Copy solution back to glimmer uvel and vvel arrays to be passed back
// ---------------------------------------------------------------------------------------------------
//std::cout << "overlapMap # global elements: " << overlapMap.NumGlobalElements() << std::endl;
//std::cout << "overlapMap # my elements: " << overlapMap.NumMyElements() << std::endl;
//std::cout << "overlapMap: " << overlapMap << std::endl;
//std::cout << "map # global elements: " << ownedMap.NumGlobalElements() << std::endl;
//std::cout << "map # my elements: " << ownedMap.NumMyElements() << std::endl;
//std::cout << "node_map # global elements: " << node_map->NumGlobalElements() << std::endl;
//std::cout << "node_map # my elements: " << node_map->NumMyElements() << std::endl;
//std::cout << "node_map: " << *node_map << std::endl;
if (debug_output_verbosity != 0 & mpiCommT->getRank() == 0)
std::cout << "In felix_driver_run: copying Albany solution to uvel and vvel to send back to CISM... " << std::endl;
#ifdef CISM_USE_EPETRA
//Epetra_Vectors to hold uvel and vvel to be passed to Glimmer/CISM
Epetra_Vector uvel(*node_map, true);
Epetra_Vector vvel(*node_map, true);
#else
//Tpetra_Vectors to hold uvel and vvel to be passed to Glimmer/CISM
Teuchos::RCP<Tpetra_Vector> uvel = Teuchos::rcp(new Tpetra_Vector(node_map, true));
Teuchos::RCP<Tpetra_Vector> vvel = Teuchos::rcp(new Tpetra_Vector(node_map, true));
#endif
#ifdef CISM_USE_EPETRA
if (interleavedOrdering == true) {
for (int i=0; i<overlapMap.NumMyElements(); i++) {
int global_dof = overlapMap.GID(i);
double sol_value = solutionOverlap[i];
int modulo = (global_dof % 2); //check if dof is for u or for v
int vel_global_dof, vel_local_dof;
if (modulo == 0) { //u dof
vel_global_dof = global_dof/2+1; //add 1 because node_map is 1-based
vel_local_dof = node_map->LID(vel_global_dof); //look up local id corresponding to global id in node_map
//std::cout << "uvel: global_dof = " << global_dof << ", uvel_global_dof = " << vel_global_dof << ", uvel_local_dof = " << vel_local_dof << std::endl;
uvel.ReplaceMyValues(1, &sol_value, &vel_local_dof);
}
else { // v dof
vel_global_dof = (global_dof-1)/2+1; //add 1 because node_map is 1-based
vel_local_dof = node_map->LID(vel_global_dof); //look up local id corresponding to global id in node_map
vvel.ReplaceMyValues(1, &sol_value, & vel_local_dof);
}
}
}
else { //note: the case with non-interleaved ordering has not been tested...
int numDofs = overlapMap.NumGlobalElements();
for (int i=0; i<overlapMap.NumMyElements(); i++) {
int global_dof = overlapMap.GID(i);
double sol_value = solutionOverlap[i];
int vel_global_dof, vel_local_dof;
if (global_dof < numDofs/2) { //u dof
vel_global_dof = global_dof+1; //add 1 because node_map is 1-based
vel_local_dof = node_map->LID(vel_global_dof); //look up local id corresponding to global id in node_map
uvel.ReplaceMyValues(1, &sol_value, &vel_local_dof);
}
else { //v dofs
vel_global_dof = global_dof-numDofs/2+1; //add 1 because node_map is 1-based
vel_local_dof = node_map->LID(vel_global_dof); //look up local id corresponding to global id in node_map
vvel.ReplaceMyValues(1, &sol_value, & vel_local_dof);
}
}
}
#else
if (interleavedOrdering == true) {
for (int i=0; i<overlapMap->getNodeNumElements(); i++) {
int global_dof = overlapMap->getGlobalElement(i);
double sol_value = solutionOverlap_constView[i];
int modulo = (global_dof % 2); //check if dof is for u or for v
int vel_global_dof, vel_local_dof;
if (modulo == 0) { //u dof
vel_global_dof = global_dof/2+1; //add 1 because node_map is 1-based
vel_local_dof = node_map->getLocalElement(vel_global_dof); //look up local id corresponding to global id in node_map
//std::cout << "uvel: global_dof = " << global_dof << ", uvel_global_dof = " << vel_global_dof << ", uvel_local_dof = " << vel_local_dof << std::endl;
uvel->replaceLocalValue(vel_local_dof, sol_value);
}
else { // v dof
vel_global_dof = (global_dof-1)/2+1; //add 1 because node_map is 1-based
vel_local_dof = node_map->getLocalElement(vel_global_dof); //look up local id corresponding to global id in node_map
vvel->replaceLocalValue(vel_local_dof, sol_value);
}
}
}
else { //note: the case with non-interleaved ordering has not been tested...
int numDofs = overlapMap->getGlobalNumElements();
for (int i=0; i<overlapMap->getNodeNumElements(); i++) {
int global_dof = overlapMap->getGlobalElement(i);
double sol_value = solutionOverlap_constView[i];
int vel_global_dof, vel_local_dof;
if (global_dof < numDofs/2) { //u dof
vel_global_dof = global_dof+1; //add 1 because node_map is 1-based
vel_local_dof = node_map->getLocalElement(vel_global_dof); //look up local id corresponding to global id in node_map
uvel->replaceLocalValue(vel_local_dof, sol_value);
}
else { //v dofs
vel_global_dof = global_dof-numDofs/2+1; //add 1 because node_map is 1-based
vel_local_dof = node_map->getLocalElement(vel_global_dof); //look up local id corresponding to global id in node_map
vvel->replaceLocalValue(vel_local_dof, sol_value);
}
}
}
#endif
#ifdef WRITE_TO_MATRIX_MARKET
//For debug: write solution to matrix market file
#ifdef CISM_USE_EPETRA
EpetraExt::MultiVectorToMatrixMarketFile("uvel.mm", uvel);
EpetraExt::MultiVectorToMatrixMarketFile("vvel.mm", vvel);
#else
Tpetra_MatrixMarket_Writer::writeDenseFile("uvel.mm", uvel);
Tpetra_MatrixMarket_Writer::writeDenseFile("vvel.mm", vvel);
#endif
#endif
//Copy uvel and vvel into uVel_ptr and vVel_ptr respectively (the arrays passed back to CISM) according to the numbering consistent w/ CISM.
counter1 = 0;
counter2 = 0;
#ifdef CISM_USE_EPETRA
#else
Teuchos::ArrayRCP<const ST> uvel_constView = uvel->get1dView();
Teuchos::ArrayRCP<const ST> vvel_constView = vvel->get1dView();
#endif
local_nodeID = 0;
for (int j=0; j<nsn-1; j++) {
for (int i=0; i<ewn-1; i++) {
for (int k=0; k<upn; k++) {
if (j >= nhalo-1 & j < nsn-nhalo) {
if (i >= nhalo-1 & i < ewn-nhalo) {
#ifdef CISM_USE_EPETRA
local_nodeID = node_map->LID(cismToAlbanyNodeNumberMap[counter1]);
//if (mpiComm->MyPID() == 0)
//std::cout << "counter1:" << counter1 << ", cismToAlbanyNodeNumberMap[counter1]: " << cismToAlbanyNodeNumberMap[counter1] << ", local_nodeID: "
//<< local_nodeID << ", uvel: " << uvel[local_nodeID] << std::endl; //uvel[local_nodeID] << std::endl;
uVel_ptr[counter2] = uvel[local_nodeID];
vVel_ptr[counter2] = vvel[local_nodeID];
#else
local_nodeID = node_map->getLocalElement(cismToAlbanyNodeNumberMap[counter1]);
uVel_ptr[counter2] = uvel_constView[local_nodeID];
vVel_ptr[counter2] = vvel_constView[local_nodeID];
#endif
counter1++;
}
}
else {
uVel_ptr[counter2] = 0.0;
vVel_ptr[counter2] = 0.0;
}
counter2++;
}
}
}
first_time_step = false;
}
void DirichletField<PHAL::AlbanyTraits::DistParamDeriv, Traits>::
evaluateFields(typename Traits::EvalData dirichletWorkset) {
bool isFieldParameter = dirichletWorkset.dist_param_deriv_name == this->field_name;
Teuchos::RCP<Tpetra_MultiVector> fpVT = dirichletWorkset.fpVT;
//non-const view of fpVT
Teuchos::ArrayRCP<ST> fpVT_nonconstView;
bool trans = dirichletWorkset.transpose_dist_param_deriv;
int num_cols = fpVT->getNumVectors();
const std::vector<std::vector<int> >& nsNodes =
dirichletWorkset.nodeSets->find(this->nodeSetID)->second;
// For (df/dp)^T*V we zero out corresponding entries in V
if (trans) {
Teuchos::RCP<Tpetra_MultiVector> VpT = dirichletWorkset.Vp_bcT;
//non-const view of VpT
Teuchos::ArrayRCP<ST> VpT_nonconstView;
if(isFieldParameter) {
#if defined(ALBANY_EPETRA)
const Albany::NodalDOFManager& fieldDofManager = dirichletWorkset.disc->getDOFManager(this->field_name);
Teuchos::RCP<const Epetra_Map> fiedNodeMap = dirichletWorkset.disc->getNodeMap(this->field_name);
const std::vector<GO>& nsNodesGIDs = dirichletWorkset.disc->getNodeSetGIDs().find(this->nodeSetID)->second;
#endif
for (unsigned int inode = 0; inode < nsNodes.size(); inode++) {
int lunk = nsNodes[inode][this->offset];
#if defined(ALBANY_EPETRA)
GO node_gid = nsNodesGIDs[inode];
int lfield = fieldDofManager.getLocalDOF(fiedNodeMap->LID(node_gid),this->offset);
#else
int lfield = lunk;
#endif
for (int col=0; col<num_cols; ++col) {
VpT_nonconstView = VpT->getDataNonConst(col);
fpVT_nonconstView = fpVT->getDataNonConst(col);
fpVT_nonconstView[lfield] -= VpT_nonconstView[lunk];
VpT_nonconstView[lunk] = 0.0;
}
}
}
else {
for (unsigned int inode = 0; inode < nsNodes.size(); inode++) {
int lunk = nsNodes[inode][this->offset];
for (int col=0; col<num_cols; ++col) {
VpT_nonconstView = VpT->getDataNonConst(col);
VpT_nonconstView[lunk] = 0.0;
}
}
}
}
// for (df/dp)*V we zero out corresponding entries in df/dp
else {
if(isFieldParameter) {
#if defined(ALBANY_EPETRA)
const Albany::NodalDOFManager& fieldDofManager = dirichletWorkset.disc->getDOFManager(this->field_name);
Teuchos::RCP<const Epetra_Map> fiedNodeMap = dirichletWorkset.disc->getNodeMap(this->field_name);
const std::vector<GO>& nsNodesGIDs = dirichletWorkset.disc->getNodeSetGIDs().find(this->nodeSetID)->second;
#endif
for (unsigned int inode = 0; inode < nsNodes.size(); inode++) {
int lunk = nsNodes[inode][this->offset];
#if defined(ALBANY_EPETRA)
GO node_gid = nsNodesGIDs[inode];
int lfield = fieldDofManager.getLocalDOF(fiedNodeMap->LID(node_gid),this->offset);
#else
int lfield = lunk;
#endif
for (int col=0; col<num_cols; ++col) {
//(*fpV)[col][lunk] = 0.0;
fpVT_nonconstView = fpVT->getDataNonConst(col);
fpVT_nonconstView[lunk] = -double(col == lfield);
}
}
}
else {
for (unsigned int inode = 0; inode < nsNodes.size(); inode++) {
int lunk = nsNodes[inode][this->offset];
for (int col=0; col<num_cols; ++col) {
fpVT_nonconstView = fpVT->getDataNonConst(col);
fpVT_nonconstView[lunk] = 0.0;
}
}
}
}
}
void PeridigmNS::Block::createMapsFromGlobalMaps(Teuchos::RCP<const Epetra_BlockMap> globalOwnedScalarPointMap,
Teuchos::RCP<const Epetra_BlockMap> globalOverlapScalarPointMap,
Teuchos::RCP<const Epetra_BlockMap> globalOwnedVectorPointMap,
Teuchos::RCP<const Epetra_BlockMap> globalOverlapVectorPointMap,
Teuchos::RCP<const Epetra_BlockMap> globalOwnedScalarBondMap,
Teuchos::RCP<const Epetra_Vector> globalBlockIds,
Teuchos::RCP<const PeridigmNS::NeighborhoodData> globalNeighborhoodData,
Teuchos::RCP<const PeridigmNS::NeighborhoodData> globalContactNeighborhoodData)
{
double* globalBlockIdsPtr;
globalBlockIds->ExtractView(&globalBlockIdsPtr);
// Create a list of all the on-processor elements that are part of this block
vector<int> IDs;
IDs.reserve(globalOverlapScalarPointMap->NumMyElements()); // upper bound
vector<int> bondIDs;
bondIDs.reserve(globalOverlapScalarPointMap->NumMyElements());
vector<int> bondElementSize;
bondElementSize.reserve(globalOwnedScalarPointMap->NumMyElements());
for(int iLID=0 ; iLID<globalOwnedScalarPointMap->NumMyElements() ; ++iLID){
if(globalBlockIdsPtr[iLID] == blockID) {
int globalID = globalOwnedScalarPointMap->GID(iLID);
IDs.push_back(globalID);
}
}
// Record the size of these elements in the bond map
// Note that if an element has no bonds, it has no entry in the bondMap
// So, the bond map and the scalar map can have a different number of entries (different local IDs)
for(int iLID=0 ; iLID<globalOwnedScalarBondMap->NumMyElements() ; ++iLID){
int globalID = globalOwnedScalarBondMap->GID(iLID);
int localID = globalOwnedScalarPointMap->LID(globalID);
if(globalBlockIdsPtr[localID] == blockID){
bondIDs.push_back(globalID);
bondElementSize.push_back(globalOwnedScalarBondMap->ElementSize(iLID));
}
}
// Create the owned scalar point map, the owned vector point map, and the owned scalar bond map
int numGlobalElements = -1;
int numMyElements = IDs.size();
int* myGlobalElements = 0;
if(numMyElements > 0)
myGlobalElements = &IDs.at(0);
int elementSize = 1;
int indexBase = 0;
ownedScalarPointMap =
Teuchos::rcp(new Epetra_BlockMap(numGlobalElements, numMyElements, myGlobalElements, elementSize, indexBase, globalOwnedScalarPointMap->Comm()));
elementSize = 3;
ownedVectorPointMap =
Teuchos::rcp(new Epetra_BlockMap(numGlobalElements, numMyElements, myGlobalElements, elementSize, indexBase, globalOwnedScalarPointMap->Comm()));
numMyElements = bondElementSize.size();
myGlobalElements = 0;
int* elementSizeList = 0;
if(numMyElements > 0){
myGlobalElements = &bondIDs.at(0);
elementSizeList = &bondElementSize.at(0);
}
ownedScalarBondMap =
Teuchos::rcp(new Epetra_BlockMap(numGlobalElements, numMyElements, myGlobalElements, elementSizeList, indexBase, globalOwnedScalarPointMap->Comm()));
// Create a list of nodes that need to be ghosted (both across material boundaries and across processor boundaries)
set<int> ghosts;
// Check the neighborhood list for things that need to be ghosted
int* const globalNeighborhoodList = globalNeighborhoodData->NeighborhoodList();
int globalNeighborhoodListIndex = 0;
for(int iLID=0 ; iLID<globalNeighborhoodData->NumOwnedPoints() ; ++iLID){
int numNeighbors = globalNeighborhoodList[globalNeighborhoodListIndex++];
if(globalBlockIdsPtr[iLID] == blockID) {
for(int i=0 ; i<numNeighbors ; ++i){
int neighborGlobalID = globalOverlapScalarPointMap->GID( globalNeighborhoodList[globalNeighborhoodListIndex + i] );
ghosts.insert(neighborGlobalID);
}
}
globalNeighborhoodListIndex += numNeighbors;
}
// Check the contact neighborhood list for things that need to be ghosted
if(!globalContactNeighborhoodData.is_null()){
int* const globalContactNeighborhoodList = globalContactNeighborhoodData->NeighborhoodList();
int globalContactNeighborhoodListIndex = 0;
for(int iLID=0 ; iLID<globalContactNeighborhoodData->NumOwnedPoints() ; ++iLID){
int numNeighbors = globalContactNeighborhoodList[globalContactNeighborhoodListIndex++];
if(globalBlockIdsPtr[iLID] == blockID) {
for(int i=0 ; i<numNeighbors ; ++i){
int neighborGlobalID = globalOverlapScalarPointMap->GID( globalContactNeighborhoodList[globalContactNeighborhoodListIndex + i] );
ghosts.insert(neighborGlobalID);
}
}
globalContactNeighborhoodListIndex += numNeighbors;
}
}
// Remove entries from ghosts that are already in IDs
for(unsigned int i=0 ; i<IDs.size() ; ++i)
ghosts.erase(IDs[i]);
// Copy IDs, this is the owned global ID list
vector<int> ownedIDs(IDs.begin(), IDs.end());
// Append ghosts to IDs
// This creates the overlap global ID list
for(set<int>::iterator it=ghosts.begin() ; it!=ghosts.end() ; ++it)
IDs.push_back(*it);
// Create the overlap scalar point map and the overlap vector point map
numMyElements = IDs.size();
myGlobalElements = 0;
if(numMyElements > 0)
myGlobalElements = &IDs.at(0);
elementSize = 1;
overlapScalarPointMap =
Teuchos::rcp(new Epetra_BlockMap(numGlobalElements, numMyElements, myGlobalElements, elementSize, indexBase, globalOwnedScalarPointMap->Comm()));
elementSize = 3;
overlapVectorPointMap =
Teuchos::rcp(new Epetra_BlockMap(numGlobalElements, numMyElements, myGlobalElements, elementSize, indexBase, globalOwnedScalarPointMap->Comm()));
// Invalidate the importers
oneDimensionalImporter = Teuchos::RCP<Epetra_Import>();
threeDimensionalImporter = Teuchos::RCP<Epetra_Import>();
}
void velocity_solver_solve_fo(int nLayers, int nGlobalVertices,
int nGlobalTriangles, bool ordering, bool first_time_step,
const std::vector<int>& indexToVertexID,
const std::vector<int>& indexToTriangleID, double minBeta,
const std::vector<double>& regulThk,
const std::vector<double>& levelsNormalizedThickness,
const std::vector<double>& elevationData,
const std::vector<double>& thicknessData,
const std::vector<double>& betaData,
const std::vector<double>& temperatureOnTetra,
std::vector<double>& velocityOnVertices) {
int numVertices3D = (nLayers + 1) * indexToVertexID.size();
int numPrisms = nLayers * indexToTriangleID.size();
int vertexColumnShift = (ordering == 1) ? 1 : nGlobalVertices;
int lVertexColumnShift = (ordering == 1) ? 1 : indexToVertexID.size();
int vertexLayerShift = (ordering == 0) ? 1 : nLayers + 1;
int elemColumnShift = (ordering == 1) ? 3 : 3 * nGlobalTriangles;
int lElemColumnShift = (ordering == 1) ? 3 : 3 * indexToTriangleID.size();
int elemLayerShift = (ordering == 0) ? 3 : 3 * nLayers;
const bool interleavedOrdering = meshStruct->getInterleavedOrdering();
Albany::AbstractSTKFieldContainer::VectorFieldType* solutionField;
if (interleavedOrdering)
solutionField = Teuchos::rcp_dynamic_cast<
Albany::OrdinarySTKFieldContainer<true> >(
meshStruct->getFieldContainer())->getSolutionField();
else
solutionField = Teuchos::rcp_dynamic_cast<
Albany::OrdinarySTKFieldContainer<false> >(
meshStruct->getFieldContainer())->getSolutionField();
typedef Albany::AbstractSTKFieldContainer::ScalarFieldType ScalarFieldType;
typedef Albany::AbstractSTKFieldContainer::QPScalarFieldType ElemScalarFieldType;
for (UInt j = 0; j < numVertices3D; ++j) {
int ib = (ordering == 0) * (j % lVertexColumnShift)
+ (ordering == 1) * (j / vertexLayerShift);
int il = (ordering == 0) * (j / lVertexColumnShift)
+ (ordering == 1) * (j % vertexLayerShift);
int gId = il * vertexColumnShift + vertexLayerShift * indexToVertexID[ib];
stk::mesh::Entity node = meshStruct->bulkData->get_entity(stk::topology::NODE_RANK, gId + 1);
double* coord = stk::mesh::field_data(*meshStruct->getCoordinatesField(), node);
coord[2] = elevationData[ib] - levelsNormalizedThickness[nLayers - il] * regulThk[ib];
double* sHeight = stk::mesh::field_data(*meshStruct->metaData->get_field <ScalarFieldType> (stk::topology::NODE_RANK, "surface_height"), node);
sHeight[0] = elevationData[ib];
double* thickness = stk::mesh::field_data(*meshStruct->metaData->get_field <ScalarFieldType> (stk::topology::NODE_RANK, "thickness"), node);
thickness[0] = thicknessData[ib];
double* sol = stk::mesh::field_data(*solutionField, node);
sol[0] = velocityOnVertices[j];
sol[1] = velocityOnVertices[j + numVertices3D];
if (il == 0) {
double* beta = stk::mesh::field_data(*meshStruct->metaData->get_field <ScalarFieldType> (stk::topology::NODE_RANK, "basal_friction"), node);
beta[0] = std::max(betaData[ib], minBeta);
}
}
ElemScalarFieldType* temperature_field = meshStruct->metaData->get_field<ElemScalarFieldType>(stk::topology::ELEMENT_RANK, "temperature");
for (UInt j = 0; j < numPrisms; ++j) {
int ib = (ordering == 0) * (j % (lElemColumnShift / 3))
+ (ordering == 1) * (j / (elemLayerShift / 3));
int il = (ordering == 0) * (j / (lElemColumnShift / 3))
+ (ordering == 1) * (j % (elemLayerShift / 3));
int gId = il * elemColumnShift + elemLayerShift * indexToTriangleID[ib];
int lId = il * lElemColumnShift + elemLayerShift * ib;
for (int iTetra = 0; iTetra < 3; iTetra++) {
stk::mesh::Entity elem = meshStruct->bulkData->get_entity(stk::topology::ELEMENT_RANK, ++gId);
double* temperature = stk::mesh::field_data(*temperature_field, elem);
temperature[0] = temperatureOnTetra[lId++];
}
}
meshStruct->setHasRestartSolution(!first_time_step);
if (!first_time_step) {
meshStruct->setRestartDataTime(
paramList->sublist("Problem").get("Homotopy Restart Step", 1.));
double homotopy =
paramList->sublist("Problem").sublist("FELIX Viscosity").get(
"Glen's Law Homotopy Parameter", 1.0);
if (meshStruct->restartDataTime() == homotopy) {
paramList->sublist("Problem").set("Solution Method", "Steady");
paramList->sublist("Piro").set("Solver Type", "NOX");
}
}
if(!keptMesh) {
albanyApp->createDiscretization();
albanyApp->finalSetUp(paramList); //, albanyApp->getDiscretization()->getSolutionFieldT());
}
else
albanyApp->getDiscretization()->updateMesh();
#ifdef MPAS_USE_EPETRA
solver = slvrfctry->createThyraSolverAndGetAlbanyApp(albanyApp, mpiComm, mpiComm, Teuchos::null, false);
#else
solver = slvrfctry->createAndGetAlbanyAppT(albanyApp, mpiCommT, mpiCommT, Teuchos::null, false);
#endif
Teuchos::ParameterList solveParams;
solveParams.set("Compute Sensitivities", false);
Teuchos::Array<Teuchos::RCP<const Thyra::VectorBase<double> > > thyraResponses;
Teuchos::Array<
Teuchos::Array<Teuchos::RCP<const Thyra::MultiVectorBase<double> > > > thyraSensitivities;
Piro::PerformSolveBase(*solver, solveParams, thyraResponses,
thyraSensitivities);
#ifdef MPAS_USE_EPETRA
const Epetra_Map& overlapMap(
*albanyApp->getDiscretization()->getOverlapMap());
Epetra_Import import(overlapMap, *albanyApp->getDiscretization()->getMap());
Epetra_Vector solution(overlapMap);
solution.Import(*albanyApp->getDiscretization()->getSolutionField(), import,
Insert);
#else
Teuchos::RCP<const Tpetra_Map> overlapMap = albanyApp->getDiscretization()->getOverlapMapT();
Teuchos::RCP<Tpetra_Import> import = Teuchos::rcp(new Tpetra_Import(albanyApp->getDiscretization()->getMapT(), overlapMap));
Teuchos::RCP<Tpetra_Vector> solution = Teuchos::rcp(new Tpetra_Vector(overlapMap));
solution->doImport(*albanyApp->getDiscretization()->getSolutionFieldT(), *import, Tpetra::INSERT);
Teuchos::ArrayRCP<const ST> solution_constView = solution->get1dView();
#endif
for (UInt j = 0; j < numVertices3D; ++j) {
int ib = (ordering == 0) * (j % lVertexColumnShift)
+ (ordering == 1) * (j / vertexLayerShift);
int il = (ordering == 0) * (j / lVertexColumnShift)
+ (ordering == 1) * (j % vertexLayerShift);
int gId = il * vertexColumnShift + vertexLayerShift * indexToVertexID[ib];
int lId0, lId1;
#ifdef MPAS_USE_EPETRA
if (interleavedOrdering) {
lId0 = overlapMap.LID(2 * gId);
lId1 = lId0 + 1;
} else {
lId0 = overlapMap.LID(gId);
lId1 = lId0 + numVertices3D;
}
velocityOnVertices[j] = solution[lId0];
velocityOnVertices[j + numVertices3D] = solution[lId1];
#else
if (interleavedOrdering) {
lId0 = overlapMap->getLocalElement(2 * gId);
lId1 = lId0 + 1;
} else {
lId0 = overlapMap->getLocalElement(gId);
lId1 = lId0 + numVertices3D;
}
velocityOnVertices[j] = solution_constView[lId0];
velocityOnVertices[j + numVertices3D] = solution_constView[lId1];
#endif
}
keptMesh = true;
//UInt componentGlobalLength = (nLayers+1)*nGlobalVertices; //mesh3DPtr->numGlobalVertices();
}
