transformed.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * This program 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, version 3.
 *
 * This program 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.
 */
#ifndef PLASK__MESH_TRANSFORMED_H
#define PLASK__MESH_TRANSFORMED_H
 
#include "mesh.hpp"
#include "../geometry/space.hpp"
 
namespace plask {
 
//TODO better version for rectangular source (with size reduction by the size of removed axis)
struct ReductionTo2DMesh: public MeshD<2> {
 
    typedef Geometry3D SourceGeometry;
 
    typedef Geometry2DCartesian TargetGeometry;
 
    enum { SRC_DIM = 3 };
 
    Vec<2,double> translation;
 
    const shared_ptr<const MeshD<3>> sourceMesh;
 
    ReductionTo2DMesh(const shared_ptr<const MeshD<3>> sourceMesh, const Vec<2,double>& translation=Primitive<2>::ZERO_VEC)
        : translation(translation), sourceMesh(sourceMesh) {}
 
    ReductionTo2DMesh(const shared_ptr<const MeshD<3>> sourceMesh, const Vec<3,double>& translation)
        : translation(vec<2>(translation)), sourceMesh(sourceMesh) {}
 
    Vec<2, double> at(std::size_t index) const override {
        return vec<2>(sourceMesh->at(index)) - translation;
    }
 
    std::size_t size() const override {
        return sourceMesh->size();
    }
};
 
 
struct PLASK_API CylReductionTo2DMesh: public MeshD<2> {
 
    typedef Geometry3D SourceGeometry;
 
    typedef Geometry2DCylindrical TargetGeometry;
 
    enum { SRC_DIM = 3 };
 
    Vec<3,double> translation;
 
    const shared_ptr<const MeshD<3>> sourceMesh;
 
    CylReductionTo2DMesh(const shared_ptr<const MeshD<3>> sourceMesh, const Vec<3,double>& translation=Primitive<3>::ZERO_VEC)
        : translation(translation), sourceMesh(sourceMesh) {}
 
    Vec<2, double> at(std::size_t index) const override {
        return rotateToLonTranAbs(sourceMesh->at(index) - translation);
    }
 
    std::size_t size() const override {
        return sourceMesh->size();
    }
 
    Vec<3,double> rVector(std::size_t index) const {
        return sourceMesh->at(index) - translation;
    }
};
 
 
class PLASK_API CartesianMesh2DTo3D: public MeshD<3> {
 
    Vec<3,double> translation;
 
    const shared_ptr<const MeshD<2>> sourceMesh;
 
public:
 
    typedef Geometry2DCartesian SourceGeometry;
 
    typedef Geometry3D TargetGeometry;
 
    enum { SRC_DIM = 2 };
 
    CartesianMesh2DTo3D(const shared_ptr<const MeshD<2>>& sourceMesh, Vec<3,double> translation=Primitive<3>::ZERO_VEC, double lon=0)
        : translation(translation), sourceMesh(sourceMesh) {
        this->translation.lon() += lon;
    }
 
    Vec<3, double> at(std::size_t index) const override {
        return vec3Dplus2D(translation, sourceMesh->at(index));
    }
 
    std::size_t size() const override {
        return sourceMesh->size();
    }
};
 
 
class PLASK_API CartesianMesh2DTo3DExtend: public MeshD<3> {
 
    const shared_ptr<const MeshD<2>> sourceMesh;
 
    Vec<3,double> translation;
 
    double stepSize;
 
    std::size_t pointsCount;
 
public:
 
    typedef Geometry2DCartesian SourceGeometry;
 
    typedef Geometry3D TargetGeometry;
 
    enum { SRC_DIM = 2 };
 
    CartesianMesh2DTo3DExtend(const shared_ptr<const MeshD<2>>& sourceMesh, const Vec<3,double>& translation, double longBegin, double lonSize, std::size_t pointsCount=10)
        : sourceMesh(sourceMesh), translation(translation), stepSize(lonSize / double(pointsCount-1)), pointsCount(pointsCount) {
        this->translation.lon() += longBegin;
    }
 
    Vec<3, double> at(std::size_t index) const override {
        return translation + vec(sourceMesh->at(index / pointsCount), stepSize * double(index));
    }
 
    std::size_t size() const override {
        return sourceMesh->size() * pointsCount;
    }
};
 
 
struct PLASK_API PointsOnCircleMeshExtend: public MeshD<3> {
 
    const shared_ptr<const MeshD<2>> sourceMesh;
 
    Vec<3,double> translation;
 
    double slice;
 
    std::size_t pointsCount;
 
    Vec<3, double> getCenterForPoint(const Vec<2, double>& p) const {
        return Vec<3, double>(this->translation.lon(), this->translation.tran(), this->translation.vert() + p.rad_z());
    }
 
public:
 
    typedef Geometry2DCylindrical SourceGeometry;
 
    typedef Geometry3D TargetGeometry;
 
    enum { SRC_DIM = 2 };
 
    PointsOnCircleMeshExtend(const shared_ptr<const MeshD<2>>& sourceMesh, const Vec<3, double>& translation=Primitive<3>::ZERO_VEC, std::size_t pointsCount=18)
        : sourceMesh(sourceMesh), translation(translation), slice(PI_DOUBLED / double(pointsCount)), pointsCount(pointsCount) {
    }
 
    Vec<3, double> at(std::size_t index) const override {
        Vec<2, double> p = sourceMesh->at(index / pointsCount);
        const double angle = slice * double(index % pointsCount);
        return Vec<3, double>(
                    this->translation.lon()  +  p.rad_r() * cos(angle),
                    this->translation.tran() +  p.rad_r() * sin(angle),
                    this->translation.vert() +  p.rad_z()
        );
    }
 
    std::size_t size() const override {
        return sourceMesh->size() * pointsCount;
    }
 
    Vec<3,double> rVector(std::size_t index) const {
        return at(index) - translation;
    }
};
 
} // namespace plask
 
#endif // PLASK__MESH_TRANSFORMED_H