Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F79089233
common.hh
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Sat, Aug 24, 17:05
Size
9 KB
Mime Type
text/x-c
Expires
Mon, Aug 26, 17:05 (2 d)
Engine
blob
Format
Raw Data
Handle
20141417
Attached To
rMUSPECTRE µSpectre
common.hh
View Options
/**
* @file common.hh
*
* @author Till Junge <till.junge@epfl.ch>
*
* @date 01 May 2017
*
* @brief Small definitions of commonly used types throughout µSpectre
*
* @section LICENSE
*
* Copyright © 2017 Till Junge
*
* µSpectre is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3, or (at
* your option) any later version.
*
* µSpectre is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Emacs; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <array>
#include <cmath>
#include <complex>
#include <iostream>
#include <type_traits>
#include <string>
#ifndef COMMON_H
#define COMMON_H
namespace
muSpectre
{
/**
* Eigen uses signed integers for dimensions. For consistency,
µSpectre uses them througout the code. needs to represent -1 for
eigen
*/
using
Dim_t
=
int
;
constexpr
Dim_t
oneD
{
1
};
//!< constant for a one-dimensional problem
constexpr
Dim_t
twoD
{
2
};
//!< constant for a two-dimensional problem
constexpr
Dim_t
threeD
{
3
};
//!< constant for a three-dimensional problem
constexpr
Dim_t
firstOrder
{
1
};
//!< constant for vectors
constexpr
Dim_t
secondOrder
{
2
};
//!< constant second-order tensors
constexpr
Dim_t
fourthOrder
{
4
};
//!< constant fourth-order tensors
//@{
//! @anchor scalars
//! Scalar types used for mathematical calculations
using
Uint
=
unsigned
int
;
using
Int
=
int
;
using
Real
=
double
;
using
Complex
=
std
::
complex
<
Real
>
;
//@}
//! Ccoord_t are cell coordinates, i.e. integer coordinates
template
<
Dim_t
dim
>
using
Ccoord_t
=
std
::
array
<
Dim_t
,
dim
>
;
//! Real space coordinates
template
<
Dim_t
dim
>
using
Rcoord_t
=
std
::
array
<
Real
,
dim
>
;
/**
* Allows inserting `muSpectre::Ccoord_t` and `muSpectre::Rcoord_t`
* into `std::ostream`s
*/
template
<
typename
T
,
size_t
dim
>
std
::
ostream
&
operator
<<
(
std
::
ostream
&
os
,
const
std
::
array
<
T
,
dim
>
&
index
)
{
os
<<
"("
;
for
(
size_t
i
=
0
;
i
<
dim
-
1
;
++
i
)
{
os
<<
index
[
i
]
<<
", "
;
}
os
<<
index
.
back
()
<<
")"
;
return
os
;
}
//! element-wise division
template
<
size_t
dim
>
Rcoord_t
<
dim
>
operator
/
(
const
Rcoord_t
<
dim
>
&
a
,
const
Rcoord_t
<
dim
>
&
b
)
{
Rcoord_t
<
dim
>
retval
{
a
};
for
(
size_t
i
=
0
;
i
<
dim
;
++
i
)
{
retval
[
i
]
/=
b
[
i
];
}
return
retval
;
}
//! element-wise division
template
<
size_t
dim
>
Rcoord_t
<
dim
>
operator
/
(
const
Rcoord_t
<
dim
>
&
a
,
const
Ccoord_t
<
dim
>
&
b
)
{
Rcoord_t
<
dim
>
retval
{
a
};
for
(
size_t
i
=
0
;
i
<
dim
;
++
i
)
{
retval
[
i
]
/=
b
[
i
];
}
return
retval
;
}
//! convenience definitions
constexpr
Real
pi
{
3.1415926535897932384626433
};
//! compile-time potentiation required for field-size computations
template
<
typename
R
,
typename
I
>
constexpr
R
ipow
(
R
base
,
I
exponent
)
{
static_assert
(
std
::
is_integral
<
I
>::
value
,
"Type must be integer"
);
R
retval
{
1
};
for
(
I
i
=
0
;
i
<
exponent
;
++
i
)
{
retval
*=
base
;
}
return
retval
;
}
/**
* Copyright banner to be printed to the terminal by executables
* Arguments are the executable's name, year of writing and the name
* + address of the copyright holder
*/
void
banner
(
std
::
string
name
,
Uint
year
,
std
::
string
cpy_holder
);
/**
* Planner flags for FFT (follows FFTW, hopefully this choice will
* be compatible with alternative FFT implementations)
* @enum muSpectre::FFT_PlanFlags
*/
enum
class
FFT_PlanFlags
{
estimate
,
//!< cheapest plan for slowest execution
measure
,
//!< more expensive plan for fast execution
patient
//!< very expensive plan for fastest execution
};
//! continuum mechanics flags
enum
class
Formulation
{
finite_strain
,
//!< causes evaluation in PK1(F)
small_strain
,
//!< causes evaluation in σ(ε)
small_strain_sym
//!< symmetric storage as vector ε
};
/**
* compile time computation of voigt vector
*/
template
<
bool
sym
=
true
>
constexpr
Dim_t
vsize
(
Dim_t
dim
)
{
if
(
sym
)
{
return
(
dim
*
(
dim
-
1
)
/
2
+
dim
);
}
else
{
return
dim
*
dim
;
}
}
//! compute the number of degrees of freedom to store for the strain
//! tenor given dimension dim
constexpr
Dim_t
dof_for_formulation
(
const
Formulation
form
,
const
Dim_t
dim
)
{
switch
(
form
)
{
case
Formulation
::
small_strain_sym:
{
return
vsize
(
dim
);
break
;
}
default
:
return
ipow
(
dim
,
2
);
break
;
}
}
//! inserts `muSpectre::Formulation`s into `std::ostream`s
std
::
ostream
&
operator
<<
(
std
::
ostream
&
os
,
Formulation
f
);
/* ---------------------------------------------------------------------- */
//! Material laws can declare which type of stress measure they provide,
//! and µSpectre will handle conversions
enum
class
StressMeasure
{
Cauchy
,
//!< Cauchy stress σ
PK1
,
//!< First Piola-Kirchhoff stress
PK2
,
//!< Second Piola-Kirchhoff stress
Kirchhoff
,
//!< Kirchhoff stress τ
Biot
,
//!< Biot stress
Mandel
,
//!< Mandel stress
no_stress_
//!< only for triggering static_asserts
};
//! inserts `muSpectre::StressMeasure`s into `std::ostream`s
std
::
ostream
&
operator
<<
(
std
::
ostream
&
os
,
StressMeasure
s
);
/* ---------------------------------------------------------------------- */
//! Material laws can declare which type of strain measure they require and
//! µSpectre will provide it
enum
class
StrainMeasure
{
Gradient
,
//!< placement gradient (δy/δx)
Infinitesimal
,
//!< small strain tensor .5(∇u + ∇uᵀ)
GreenLagrange
,
//!< Green-Lagrange strain .5(Fᵀ·F - I)
Biot
,
//!< Biot strain
Log
,
//!< logarithmic strain
Almansi
,
//!< Almansi strain
RCauchyGreen
,
//!< Right Cauchy-Green tensor
LCauchyGreen
,
//!< Left Cauchy-Green tensor
no_strain_
//!< only for triggering static_assert
};
//! inserts `muSpectre::StrainMeasure`s into `std::ostream`s
std
::
ostream
&
operator
<<
(
std
::
ostream
&
os
,
StrainMeasure
s
);
/* ---------------------------------------------------------------------- */
/**
* all isotropic elastic moduli to identify conversions, such as E
* = µ(3λ + 2µ)/(λ+µ). For the full description, see
* https://en.wikipedia.org/wiki/Lam%C3%A9_parameters
* Not all the conversions are implemented, so please add as needed
*/
enum
class
ElasticModulus
{
Bulk
,
//!< Bulk modulus K
K
=
Bulk
,
//!< alias for ``ElasticModulus::Bulk``
Young
,
//!< Young's modulus E
E
=
Young
,
//!< alias for ``ElasticModulus::Young``
lambda
,
//!< Lamé's first parameter λ
Shear
,
//!< Shear modulus G or µ
G
=
Shear
,
//!< alias for ``ElasticModulus::Shear``
mu
=
Shear
,
//!< alias for ``ElasticModulus::Shear``
Poisson
,
//!< Poisson's ratio ν
nu
=
Poisson
,
//!< alias for ``ElasticModulus::Poisson``
Pwave
,
//!< P-wave modulus M
M
=
Pwave
,
//!< alias for ``ElasticModulus::Pwave``
no_modulus_
};
//!< only for triggering static_asserts
/**
* define comparison in order to exploit that moduli can be
* expressed in terms of any two other moduli in any order (e.g. K
* = K(E, ν) = K(ν, E)
*/
constexpr
inline
bool
operator
<
(
ElasticModulus
A
,
ElasticModulus
B
)
{
return
static_cast
<
int
>
(
A
)
<
static_cast
<
int
>
(
B
);
}
/* ---------------------------------------------------------------------- */
/** Compile-time function to g strain measure stored by muSpectre
depending on the formulation
**/
constexpr
StrainMeasure
get_stored_strain_type
(
Formulation
form
)
{
switch
(
form
)
{
case
Formulation
::
finite_strain:
{
return
StrainMeasure
::
Gradient
;
break
;
}
case
Formulation
::
small_strain:
{
return
StrainMeasure
::
Infinitesimal
;
break
;
}
default
:
return
StrainMeasure
::
no_strain_
;
break
;
}
}
/** Compile-time function to g stress measure stored by muSpectre
depending on the formulation
**/
constexpr
StressMeasure
get_stored_stress_type
(
Formulation
form
)
{
switch
(
form
)
{
case
Formulation
::
finite_strain:
{
return
StressMeasure
::
PK1
;
break
;
}
case
Formulation
::
small_strain:
{
return
StressMeasure
::
Cauchy
;
break
;
}
default
:
return
StressMeasure
::
no_stress_
;
break
;
}
}
/* ---------------------------------------------------------------------- */
/** Compile-time functions to get the stress and strain measures
after they may have been modified by choosing a formulation.
For instance, a law that expecs a Green-Lagrange strain as input
will get the infinitesimal strain tensor instead in a small
strain computation
**/
constexpr
StrainMeasure
get_formulation_strain_type
(
Formulation
form
,
StrainMeasure
expected
)
{
switch
(
form
)
{
case
Formulation
::
finite_strain:
{
return
expected
;
break
;
}
case
Formulation
::
small_strain:
{
return
get_stored_strain_type
(
form
);
break
;
}
default
:
return
StrainMeasure
::
no_strain_
;
break
;
}
}
}
// muSpectre
#ifndef EXPLICITLY_TURNED_ON_CXX17
#include "common/utilities.hh"
#endif
#endif
/* COMMON_H */
Event Timeline
Log In to Comment