void CylindricalMapping2D<Conf>::mappingImpl(
const typename Conf::differential_geometry_t& dg,
typename Conf::scalar_t& s,
typename Conf::scalar_t& t,
typename Conf::scalar_t& dsdx,
typename Conf::scalar_t& dtdx,
typename Conf::scalar_t& dsdy,
typename Conf::scalar_t& dtdy
)const
{
cylinder(dg.point,s,t);
scalar_t sx,tx,sy,ty;
const scalar_t delta(.01f);
const scalar_t inv_delta(100.f);
cylinder(dg.point + delta * dg.dpdx, sx,tx);
dsdx = (sx-s) * inv_delta;
dtdx = (tx - t) * inv_delta;
if (dtdx > scalar_t(0.5f)) dtdx = 1 - dtdx;
else if(dtdx < scalar_t(-0.5f)) dtdx = -(dtdx + 1);
cylinder(dg.point + delta * dg.dpdy,sy,ty);
dsdy = (sy - s ) * inv_delta;
dtdy = (ty - t) * inv_delta;
if (dtdy > scalar_t(0.5f)) dtdy = 1 - dtdy;
else if(dtdy < scalar_t(-0.5f)) dtdy = -(dtdy + 1);
}
void SphericalMapping2D<Conf>::mappingImpl(
const typename Conf::differential_geometry_t& dg,
typename Conf::scalar_t& s,
typename Conf::scalar_t& t,
typename Conf::scalar_t& dsdx,
typename Conf::scalar_t& dtdx,
typename Conf::scalar_t& dsdy,
typename Conf::scalar_t& dtdy
)const
{
// sphere
sphere(dg.point,s,t);
//
// texture coordinate differentials for sphere u,v
scalar_t sx,tx,sy,ty;
const scalar_t delta(0.1f);
const scalar_t inv_delta(10.f);
sphere(dg.point + delta * dg.dpdx,sx,tx);
dsdx = (sx - s ) * (inv_delta);
dtdx = (tx - t) * (inv_delta);
if(dtdx > scalar_t(0.5f)) dtdx = 1 - dtdx;
else if(dtdx < scalar_t(-0.5f)) dtdx = -(dtdx + 1);
sphere(dg.point + delta * dg.dpdy,sy,ty);
dsdy = (sy - s) * (inv_delta);
dtdy = (ty - t) * inv_delta;
if(dtdy > scalar_t(0.5f)) dtdy = 1 - dtdy;
else if(dtdy < scalar_t(-0.5f))dtdy = -(dtdy + 1);
}
// constructor from a many_body_operator, a fundamental_operator_set and a map (UseMap = true)
imperative_operator(triqs::operators::many_body_operator_generic<scalar_t> const &op, fundamental_operator_set const &fops,
hilbert_map_t hmap = hilbert_map_t(), std::vector<sub_hilbert_space> const *sub_spaces_set = nullptr) {
sub_spaces = sub_spaces_set;
hilbert_map = hmap;
if ((hilbert_map.size() == 0) != !UseMap) TRIQS_RUNTIME_ERROR << "Internal error";
// The goal here is to have a transcription of the many_body_operator in terms
// of simple vectors (maybe the code below could be more elegant)
for (auto const &term : op) {
std::vector<int> dag, ndag;
uint64_t d_mask = 0, dag_mask = 0;
for (auto const &canonical_op : term.monomial) {
(canonical_op.dagger ? dag : ndag).push_back(fops[canonical_op.indices]);
(canonical_op.dagger ? dag_mask : d_mask) |= (uint64_t(1) << fops[canonical_op.indices]);
}
auto compute_count_mask = [](std::vector<int> const &d) {
uint64_t mask = 0;
bool is_on = (d.size() % 2 == 1);
for (int i = 0; i < 64; ++i) {
if (std::find(begin(d), end(d), i) != end(d))
is_on = !is_on;
else if (is_on)
mask |= (uint64_t(1) << i);
}
return mask;
};
uint64_t d_count_mask = compute_count_mask(ndag), dag_count_mask = compute_count_mask(dag);
all_terms.push_back(one_term_t{scalar_t(term.coef), d_mask, dag_mask, d_count_mask, dag_count_mask});
}
}
void CompileTimeArithmetic_unit_value_divide()
{
typedef unit_value_t<meters, 2> mRatio;
typedef unit_value_t<feet, 656168, 100000> ftRatio; // 2 meter
using product = unit_value_divide<mRatio, mRatio>;
ASSERT_EQUAL(scalar_t(1), product::value());
ASSERT((traits::is_unit_value_t_category<category::scalar_unit, product>));
using productM = unit_value_divide<mRatio, ftRatio>;
ASSERT((std::is_same<typename std::decay<scalar_t>::type, typename std::decay<decltype(productM::value())>::type>::value));
ASSERT_EQUAL_DELTA(1., productM::value().to<double>(), 5.0e-7);
ASSERT((traits::is_unit_value_t_category<category::scalar_unit, productM>));
using productF = unit_value_divide<ftRatio, mRatio>;
ASSERT((std::is_same<typename std::decay<scalar_t>::type, typename std::decay<decltype(productF::value())>::type>::value));
ASSERT_EQUAL_DELTA(1.0, productF::value().to<double>(), 5.0e-6);
ASSERT((traits::is_unit_value_t_category<category::scalar_unit, productF>));
using productF2 = unit_value_divide<ftRatio, ftRatio>;
ASSERT((std::is_same<typename std::decay<scalar_t>::type, typename std::decay<decltype(productF2::value())>::type>::value));
ASSERT_EQUAL_DELTA(1.0, productF2::value().to<double>(), 5.0e-8);
ASSERT((traits::is_unit_value_t_category<category::scalar_unit, productF2>));
typedef unit_value_t<seconds, 10> sRatio;
using productMS = unit_value_divide<mRatio, sRatio>;
ASSERT((std::is_same<typename std::decay<meters_per_second_t>::type, typename std::decay<decltype(productMS::value())>::type>::value));
ASSERT_EQUAL_DELTA(0.2, productMS::value().to<double>(), 5.0e-8);
ASSERT((traits::is_unit_value_t_category<category::velocity_unit, productMS>));
typedef unit_value_t<angle::radian, 20> rRatio;
using productRS = unit_value_divide<rRatio, sRatio>;
ASSERT((std::is_same<typename std::decay<radians_per_second_t>::type, typename std::decay<decltype(productRS::value())>::type>::value));
ASSERT_EQUAL_DELTA(2, productRS::value().to<double>(), 5.0e-8);
ASSERT_EQUAL_DELTA(114.592, (productRS::value().convert<degrees_per_second>().to<double>()), 5.0e-4);
ASSERT((traits::is_unit_value_t_category<category::angular_velocity_unit, productRS>));
}
// ProjectiveCamera Public Methods
ProjectiveCamera(const transform_t &world2cam,
const transform_t &proj, const scalar_t Screen[4],
scalar_t hither, scalar_t yon,
scalar_t sopen, scalar_t sclose,
scalar_t lensr, scalar_t focald, film_ptr film)
: parent_type(world2cam, hither, yon, sopen, sclose, film) {
// Initialize depth of field parameters
LensRadius = lensr;
FocalDistance = focald;
// Compute projective camera transformations
CameraToScreen = proj;
WorldToScreen = CameraToScreen * world2cam;
// Compute projective camera screen transformations
ScreenToRaster.identity();
ScreenToRaster.scale(vector_t((scalar_t)film->xResolution(),scalar_t(film->yResolution()), 1.f)).scale
(vector_t(1.f / (Screen[1] - Screen[0]),1.f / (Screen[2] - Screen[3]), 1.f)).translate
(vector_t(-Screen[0], -Screen[3], 0.f));
RasterToScreen = ScreenToRaster.inverse();
transform_t tmp = CameraToScreen.inverse();
RasterToCamera =
CameraToScreen.inverse() * RasterToScreen;
}
