SolverThread::SolverThread(QObject *parent)
: BaseSolverThread(parent)
{
m_mesh = new FEMTetrahedronMesh;
bool hasData = 0;
#if TESTBLOCK
m_mesh->generateBlocks(64,2,2, .5f, .5f, .5f);
m_mesh->setDensity(30.f);
#else
hasData = readMeshFromFile();
if(!hasData)
m_mesh->generateTest();
m_mesh->setDensity(10.4f);
#endif
unsigned totalPoints = m_mesh->numPoints();
ConjugateGradientSolver::init(totalPoints);
m_K_row = new MatrixMap[totalPoints];
m_V = new Vector3F[totalPoints];
m_F = new Vector3F[totalPoints];
m_F0 = new Vector3F[totalPoints];
int * fixed = isFixed();
unsigned i;
for(i=0; i < totalPoints; i++) m_V[i].setZero();
if(hasData) {
unsigned * anchor = (unsigned *)m_meshData.m_anchorBuf->data();
for(i=0; i < totalPoints; i++) {
fixed[i] = anchor[i];
}
}
else {
Vector3F * Xi = m_mesh->Xi();
for(i=0; i < totalPoints; i++) {
if(i==7 || i==5 || i==8 || i==18)
//if(Xi[i].x<.1f)
fixed[i]=1;
else
fixed[i]=0;
}
}
calculateK();
clearStiffnessAssembly();
m_mesh->recalcMassMatrix(fixed);
initializePlastic();
qDebug()<<"num points "<<m_mesh->numPoints();
qDebug()<<"total mass "<<m_mesh->mass();
qDebug()<<"num tetrahedrons "<<m_mesh->numTetrahedra();
qDebug()<<"total volume "<<m_mesh->volume0();
m_stiffnessMatrix = new CudaCSRMatrix;
m_hostK = new BaseBuffer;
}
void SahWorldInterface::create(CudaDynamicWorld * world)
{
#if COLLIDEJUST
return DynamicWorldInterface::create(world);
#endif
world->setBvhBuilder(new SahBuilder);
SahTetrahedronSystem * tetra = new SahTetrahedronSystem;
if(!readMeshFromFile(tetra)) createTestMesh(tetra);
resetVelocity(tetra);
tetra->setTotalMass(4000.f);
world->addTetrahedronSystem(tetra);
}
GridAdapter::GridAdapter(const std::string& filename)
: _name(""), _nodes(new std::vector<GEOLIB::Point*>), _elems(new std::vector<Element*>), _mesh(NULL)
{
readMeshFromFile(filename);
}
QList<SolutionArray *> SolutionAgros::solveSolutioArray(Hermes::vector<EssentialBCs> bcs)
{
QTime time;
// solution agros array
QList<SolutionArray *> solutionArrayList;
// load the mesh file
mesh = readMeshFromFile(tempProblemFileName() + ".mesh");
refineMesh(mesh, true, true);
// create an H1 space
Hermes::vector<Space *> space;
// create hermes solution array
Hermes::vector<Solution *> solution;
// create reference solution
Hermes::vector<Solution *> solutionReference;
// projection norms
Hermes::vector<ProjNormType> projNormType;
// prepare selector
Hermes::vector<RefinementSelectors::Selector *> selector;
// error marker
bool isError = false;
RefinementSelectors::Selector *select = NULL;
switch (adaptivityType)
{
case AdaptivityType_H:
select = new RefinementSelectors::HOnlySelector();
break;
case AdaptivityType_P:
select = new RefinementSelectors::H1ProjBasedSelector(RefinementSelectors::H2D_P_ANISO,
Util::config()->convExp,
H2DRS_DEFAULT_ORDER);
break;
case AdaptivityType_HP:
select = new RefinementSelectors::H1ProjBasedSelector(RefinementSelectors::H2D_HP_ANISO,
Util::config()->convExp,
H2DRS_DEFAULT_ORDER);
break;
}
for (int i = 0; i < numberOfSolution; i++)
{
space.push_back(new H1Space(mesh, &bcs[i], polynomialOrder));
// set order by element
for (int j = 0; j < Util::scene()->labels.count(); j++)
if (Util::scene()->labels[j]->material != Util::scene()->materials[0])
space.at(i)->set_uniform_order(Util::scene()->labels[j]->polynomialOrder > 0 ? Util::scene()->labels[j]->polynomialOrder : polynomialOrder,
QString::number(j).toStdString());
// solution agros array
solution.push_back(new Solution());
if (adaptivityType != AdaptivityType_None)
{
// add norm
projNormType.push_back(Util::config()->projNormType);
// add refinement selector
selector.push_back(select);
// reference solution
solutionReference.push_back(new Solution());
}
}
// check for DOFs
if (Space::get_num_dofs(space) == 0)
{
m_progressItemSolve->emitMessage(QObject::tr("DOF is zero"), true);
}
else
{
for (int i = 0; i < numberOfSolution; i++)
{
// transient
if (analysisType == AnalysisType_Transient)
{
// constant initial solution
solution.at(i)->set_const(mesh, initialCondition);
solutionArrayList.append(solutionArray(solution.at(i)));
}
// nonlinear
if ((linearityType != LinearityType_Linear) && (analysisType != AnalysisType_Transient))
{
solution.at(i)->set_const(mesh, 0.0);
}
}
actualTime = 0.0;
// update time function
Util::scene()->problemInfo()->hermes()->updateTimeFunctions(actualTime);
m_wf->set_current_time(actualTime);
m_wf->solution = solution;
m_wf->delete_all();
m_wf->registerForms();
// emit message
if (adaptivityType != AdaptivityType_None)
m_progressItemSolve->emitMessage(QObject::tr("Adaptivity type: %1").arg(adaptivityTypeString(adaptivityType)), false);
double error = 0.0;
// solution
int maxAdaptivitySteps = (adaptivityType == AdaptivityType_None) ? 1 : adaptivitySteps;
int actualAdaptivitySteps = -1;
for (int i = 0; i<maxAdaptivitySteps; i++)
{
// set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix *matrix = create_matrix(matrixSolver);
Vector *rhs = create_vector(matrixSolver);
Solver *solver = create_linear_solver(matrixSolver, matrix, rhs);
if (adaptivityType == AdaptivityType_None)
{
if (analysisType != AnalysisType_Transient)
solve(space, solution, solver, matrix, rhs);
}
else
{
// construct globally refined reference mesh and setup reference space.
Hermes::vector<Space *> spaceReference = *Space::construct_refined_spaces(space);
// assemble reference problem.
solve(spaceReference, solutionReference, solver, matrix, rhs);
if (!isError)
{
// project the fine mesh solution onto the coarse mesh.
OGProjection::project_global(space, solutionReference, solution, matrixSolver);
// Calculate element errors and total error estimate.
Adapt adaptivity(space, projNormType);
// Calculate error estimate for each solution component and the total error estimate.
error = adaptivity.calc_err_est(solution,
solutionReference) * 100;
// emit signal
m_progressItemSolve->emitMessage(QObject::tr("Adaptivity rel. error (step: %2/%3, DOFs: %4/%5): %1%").
arg(error, 0, 'f', 3).
arg(i + 1).
arg(maxAdaptivitySteps).
arg(Space::get_num_dofs(space)).
arg(Space::get_num_dofs(spaceReference)), false, 1);
// add error to the list
m_progressItemSolve->addAdaptivityError(error, Space::get_num_dofs(space));
if (error < adaptivityTolerance || Space::get_num_dofs(space) >= adaptivityMaxDOFs)
{
break;
}
if (i != maxAdaptivitySteps-1) adaptivity.adapt(selector,
Util::config()->threshold,
Util::config()->strategy,
Util::config()->meshRegularity);
actualAdaptivitySteps = i+1;
}
if (m_progressItemSolve->isCanceled())
{
isError = true;
break;
}
// delete reference space
for (int i = 0; i < spaceReference.size(); i++)
{
delete spaceReference.at(i)->get_mesh();
delete spaceReference.at(i);
}
spaceReference.clear();
}
// clean up.
delete solver;
delete matrix;
delete rhs;
}
// delete reference solution
for (int i = 0; i < solutionReference.size(); i++)
delete solutionReference.at(i);
solutionReference.clear();
// delete selector
if (select) delete select;
selector.clear();
// timesteps
if (!isError)
{
SparseMatrix *matrix = NULL;
Vector *rhs = NULL;
Solver *solver = NULL;
// allocate dp for transient solution
DiscreteProblem *dpTran = NULL;
if (analysisType == AnalysisType_Transient)
{
// set up the solver, matrix, and rhs according to the solver selection.
matrix = create_matrix(matrixSolver);
rhs = create_vector(matrixSolver);
solver = create_linear_solver(matrixSolver, matrix, rhs);
// solver->set_factorization_scheme(HERMES_REUSE_FACTORIZATION_COMPLETELY);
dpTran = new DiscreteProblem(m_wf, space, true);
}
int timesteps = (analysisType == AnalysisType_Transient) ? floor(timeTotal/timeStep) : 1;
for (int n = 0; n<timesteps; n++)
{
// set actual time
actualTime = (n+1)*timeStep;
// update essential bc values
Space::update_essential_bc_values(space, actualTime);
// update timedep values
Util::scene()->problemInfo()->hermes()->updateTimeFunctions(actualTime);
m_wf->set_current_time(actualTime);
m_wf->delete_all();
m_wf->registerForms();
// transient
if ((timesteps > 1) && (linearityType == LinearityType_Linear))
isError = !solveLinear(dpTran, space, solution,
solver, matrix, rhs);
if ((timesteps > 1) && (linearityType != LinearityType_Linear))
isError = !solve(space, solution,
solver, matrix, rhs);
// output
for (int i = 0; i < numberOfSolution; i++)
{
solutionArrayList.append(solutionArray(solution.at(i), space.at(i), error, actualAdaptivitySteps, (n+1)*timeStep));
}
if (analysisType == AnalysisType_Transient)
m_progressItemSolve->emitMessage(QObject::tr("Transient time step (%1/%2): %3 s").
arg(n+1).
arg(timesteps).
arg(actualTime, 0, 'e', 2), false, n+2);
if (m_progressItemSolve->isCanceled())
{
isError = true;
break;
}
}
// clean up
if (solver) delete solver;
if (matrix) delete matrix;
if (rhs) delete rhs;
if (dpTran) delete dpTran;
}
}
// delete mesh
delete mesh;
// delete space
for (unsigned int i = 0; i < space.size(); i++)
{
// delete space.at(i)->get_mesh();
delete space.at(i);
}
space.clear();
// delete last solution
for (unsigned int i = 0; i < solution.size(); i++)
delete solution.at(i);
solution.clear();
if (isError)
{
for (int i = 0; i < solutionArrayList.count(); i++)
delete solutionArrayList.at(i);
solutionArrayList.clear();
}
return solutionArrayList;
}