date:20221108

[deal.II] Postdoc or Ph.D. positions in Augsburg, Bochum and Munich

2022-11-08 Thread Martin Kronbichler


Dear all,

For our project "PDExa: Optimized software methods for solving partial
differential equations on exascale supercomputers", we are currently
looking for applications for PhD or PostDoc positions on the
development of HPC aspects of the deal.II library.

The project is a collaborative effort between five PIs at four
Universities in Germany, in Augsburg, Bochum, Karlsruhe and Munich.
We strive to develop new classes of algorithms and implementations
for the efficient solution of partial differential equations on evolving
exascale hardware. The discretization methods involve
continuous and discontinuous finite element schemes, to be
integrated into the matrix-free, multigrid and parallel linear algebra
modules of deal.II. The project is also looking into a variety of
applications, including fluid dynamics, pollutant transport and plasma
physics.

For more information on the planned research, the announced positions
and how to apply please see:
https://www.uni-augsburg.de/de/fakultaet/mntf/math/prof/hpc/pdexa/positions

If you have questions, you can also contact me directly at
martin.kronbich...@uni-a.de

Best regards,
Martin

--
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see 
https://groups.google.com/d/forum/dealii?hl=en
--- 
You received this message because you are subscribed to the Google Groups "deal.II User Group" group.

To unsubscribe from this group and stop receiving emails from it, send an email 
to dealii+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/dealii/0d14ef7e-a4f5-22d4-e486-79f6e2617060%40gmail.com.

[deal.II] Gradient Postprocessor not working

2022-11-08 Thread Abbas

So I copied what's in the link 

 verbatim 
to step 8 but it says that I am "trying to use functionality in deal.II 
that is currently not implemented" 
I attached the code below. 
I'll use the default approach for outputting gradients of a vector; is 
there a dealii step that does this?  

-- 
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see 
https://groups.google.com/d/forum/dealii?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"deal.II User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to dealii+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/dealii/a4f172ee-d4b4-4fc9-8347-21ddf33e018bn%40googlegroups.com.
/* -
 *
 * Copyright (C) 2000 - 2021 by the deal.II authors
 *
 * This file is part of the deal.II library.
 *
 * The deal.II library is free software; you can use it, redistribute
 * it, and/or modify it under the terms of the GNU Lesser General
 * Public License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * The full text of the license can be found in the file LICENSE.md at
 * the top level directory of deal.II.
 *
 * -

 *
 * Author: Wolfgang Bangerth, University of Heidelberg, 2000
 */


#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 

#include 
#include 

#include 

#include 
#include 
#include 
#include 

#include 
#include 

#include 
#include 

namespace Step8
{
  using namespace dealii;

  template 
class GradientPostprocessor : public DataPostprocessorTensor
{
public:
  GradientPostprocessor ()
:
DataPostprocessorTensor ("grad_u",
  update_gradients)
  {}
 
  virtual
  void
  evaluate_vector_field
  (const DataPostprocessorInputs::Vector &input_data,
   std::vector > &computed_quantities) const override
  {
// ensure that there really are as many output slots
// as there are points at which DataOut provides the
// gradients:
AssertDimension (input_data.solution_gradients.size(),
 computed_quantities.size());
 
for (unsigned int p=0; p::n_independent_components));
for (unsigned int d=0; d::component_to_unrolled_index(TableIndices<2>(d,e))]
  = input_data.solution_gradients[p][d][e];
  }
  }
};
  template 
  class ElasticProblem
  {
  public:
ElasticProblem();
void run();

  private:
void setup_system();
void assemble_system();
void solve();
void refine_grid();
void output_results(const unsigned int cycle) const;

Triangulation triangulation;
DoFHandlerdof_handler;

FESystem fe;

AffineConstraints constraints;

SparsityPattern  sparsity_pattern;
SparseMatrix system_matrix;

Vector solution;
Vector system_rhs;
  };



  template 
  void right_hand_side(const std::vector> &points,
   std::vector> &  values)
  {
AssertDimension(values.size(), points.size());
Assert(dim >= 2, ExcNotImplemented());

Point point_1, point_2;
point_1(0) = 0.5;
point_2(0) = -0.5;

for (unsigned int point_n = 0; point_n < points.size(); ++point_n)
  {
if (((points[point_n] - point_1).norm_square() < 0.2 * 0.2) ||
((points[point_n] - point_2).norm_square() < 0.2 * 0.2))
  values[point_n][0] = 1.0;
else
  values[point_n][0] = 0.0;

if (points[point_n].norm_square() < 0.2 * 0.2)
  values[point_n][1] = 1.0;
else
  values[point_n][1] = 0.0;
  }
  }






  template 
  ElasticProblem::ElasticProblem()
: dof_handler(triangulation)
, fe(FE_Q(1), dim)
  {}



  template 
  void ElasticProblem::setup_system()
  {
dof_handler.distribute_dofs(fe);
solution.reinit(dof_handler.n_dofs());
system_rhs.reinit(dof_handler.n_dofs());

constraints.clear();
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
 0,
 Functions::ZeroFunction(dim),
 constraints);
constraints.close();

DynamicSparsityPattern dsp(dof_handler.n_dofs(), dof_handler.n_dofs());
DoFTools::make_sparsity_pattern(dof_handler,
dsp,
constraints,
/*keep_constrained_dofs = */ false);
sparsity_pattern.copy_from(dsp);

system_matrix.reinit(sparsity_pattern);

[deal.II] Doubts regarding applying RHS forces

2022-11-08 Thread Deepika Kushwah

Hello,

I am trying to solve a 2D elasticity problem (step 8) by considering a
cantilever beam which is fixed at the right end and on the left end there
is traction.

But I am facing the following issues:
1. While considering only body forces my code is not working (no traction
case).
2. When I am neglecting the body forces and considering only traction then
code is working but solutions are not correct (no body force case).

Please see the attached code for both issues and advise.


-- 
Thanks and Regards

Deepika Kushwah
PhD Scholar, School of Mechanical Science,
IIT Goa

-- 
**

This e-mail is for the sole use of the intended recipient(s) and may

contain confidential and privileged information. If you are not the

intended recipient, please contact the sender by reply e-mail and destroy

all copies and the original message. Any unauthorized review, use,

disclosure, dissemination, forwarding, printing or copying of this email


is strictly prohibited and appropriate legal action will be taken. 




-- 
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see 
https://groups.google.com/d/forum/dealii?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"deal.II User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to dealii+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/dealii/CAKTdrppatXH%3Dio%3DpETZbwsJm-%2BKT856fjR0KPckQ9dEemfD2kQ%40mail.gmail.com.
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
//#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

namespace Step8
{
  using namespace dealii;

  template 
  class ElasticProblem
  {
  public:
ElasticProblem ();
~ElasticProblem ();
void run ();

  private:
void setup_system ();
void assemble_system ();
void solve ();
void refine_grid ();
void output_results (const unsigned int cycle) const;

Triangulation   triangulation;
DoFHandler  dof_handler;

FESystemfe;

AffineConstraints constraints;
//ConstraintMatrix hanging_node_constraints;

//QGauss   quadrature_formula;  //Quadrature
//QGauss face_quadrature_formula; //Face Quadrature
  
SparsityPattern  sparsity_pattern;
SparseMatrix system_matrix;

Vector   solution;
Vector   system_rhs;

 std::vector nodal_solution_names;

int ncx, ncy;
  };


template 
void right_hand_side(const std::vector> &points,
 std::vector> &  values)
{
  AssertDimension(values.size(), points.size());
  Assert(dim >= 2, ExcNotImplemented());
  for (unsigned int point_n = 0; point_n < points.size(); ++point_n)
  {
   values[point_n][0] = 0;
   values[point_n][1] = 10;
   }
   }
/*
template 
class RightHandSide : public Function
{
public:
  virtual double value(const Point & p,
   const unsigned int component = 0) const override;
};
8*/

  template 
  ElasticProblem::ElasticProblem ()
:
dof_handler (triangulation),
fe (FE_Q(1), dim)
   // quadrature_formula(quadRule),
  //  face_quadrature_formula(quadRule)
  {}
/*
  template 
 ElasticProblem::~ElasticProblem ()
  {
dof_handler.clear ();
  }
*/
  template 
  void ElasticProblem::setup_system ()
  {
dof_handler.distribute_dofs (fe);
constraints.clear();
//hanging_node_constraints.clear ();
DoFTools::make_hanging_node_constraints (dof_handler,

 constraints);
  /* 
VectorTools::interpolate_boundary_values(dof_handler,
   0,
   Functions::ZeroFunction(dim),
   constraints);
   */
constraints.close();

  DynamicSparsityPattern dsp(dof_handler.n_dofs(), dof_handler.n_dofs());
  DoFTools::make_sparsity_pattern(dof_handler,
  dsp,
  constraints,
  /*keep_constrained_dofs = */ false);
  sparsity_pattern.copy_from(dsp);
//hanging_node_constraints.close ();
/*
sparsity_pattern.reinit (dof_handler.n_dofs(),
 dof_handler.n_dofs(),
 dof_handler.max_couplings_between_dofs());
DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);

constraints.condense (sparsity_pattern);

sparsity_pattern.compress();
*/
sy

Re: [deal.II] Doubts regarding applying RHS forces

2022-11-08 Thread Wolfgang Bangerth


On 11/8/22 10:23, Deepika Kushwah wrote:


But I am facing the following issues:
1. While considering only body forces my code is not working (no traction case).
2. When I am neglecting the body forces and considering only traction then 
code is working but solutions are not correct (no body force case).


Deepika:
we don't know what it is you want to do, and so there is nothing we can help 
you only knowing that it "is not working" -- we don't know what is wrong, what 
the correct output would be, etc. You need to debug the situation yourself, or 
at least substantially narrow down what the difference between your 
expectation and reality is.


I will point you at a paper that talks about the process of debugging problems 
like yours and that I posted about yesterday:

  https://www.sciencedirect.com/science/article/pii/S0997753822002753
If you want a pdf version of it, you can find it here:
  https://arxiv.org/abs/2209.04198

Best
 WB

--

Wolfgang Bangerth  email: bange...@colostate.edu
   www: http://www.math.colostate.edu/~bangerth/


--
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see 
https://groups.google.com/d/forum/dealii?hl=en
--- 
You received this message because you are subscribed to the Google Groups "deal.II User Group" group.

To unsubscribe from this group and stop receiving emails from it, send an email 
to dealii+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/dealii/3acc854b-8b7f-35eb-4699-3b6f4fb538d8%40colostate.edu.

[deal.II] Postdoc or Ph.D. positions in Augsburg, Bochum and Munich

[deal.II] Gradient Postprocessor not working

[deal.II] Doubts regarding applying RHS forces

Re: [deal.II] Doubts regarding applying RHS forces

4 matches

Site Navigation

Mail list logo

Footer information