IrregularDomain.h 6.84 KB
Newer Older
1
//
frey_m's avatar
frey_m committed
2 3
// Class IrregularDomain
//   Defines a common abstract interface for different types of boundaries.
4
//
frey_m's avatar
frey_m committed
5 6 7
// Copyright (c) 2010 - 2013, Yves Ineichen, ETH Zürich,
//               2013 - 2015, Tülin Kaman, Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved
8
//
frey_m's avatar
frey_m committed
9
// Implemented as part of the PhD thesis
frey_m's avatar
frey_m committed
10
// "Toward massively parallel multi-objective optimization with application to
frey_m's avatar
frey_m committed
11 12 13 14 15 16 17 18 19 20 21
// particle accelerators" (https://doi.org/10.3929/ethz-a-009792359)
//
// This file is part of OPAL.
//
// OPAL 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 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
22
//
gsell's avatar
gsell committed
23 24 25 26 27
#ifndef IRREGULAR_DOMAIN_H
#define IRREGULAR_DOMAIN_H

#include <vector>
#include <string>
28
#include "Algorithms/PBunchDefs.h"
29
#include "Algorithms/Quaternion.h"
30
#include "Algorithms/PartBunchBase.h"
31

gsell's avatar
gsell committed
32 33 34 35 36 37 38
/// enumeration corresponding to different interpolation methods at the boundary
enum {
    CONSTANT,
    LINEAR,
    QUADRATIC
};

39

gsell's avatar
gsell committed
40 41 42 43 44 45 46
class IrregularDomain {

public:

    /** method to compute the intersection points with the boundary geometry (stored in some appropriate data structure)
     * \param hr updated mesh spacings
     */
47 48
    virtual void compute(Vector_t hr) = 0;
    virtual void compute(Vector_t hr, NDIndex<3> localId) = 0;
gsell's avatar
gsell committed
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
    /** method to get the number of gridpoints in a given z plane
     * \param z coordinate of the z plane
     * \return int number of grid nodes in the given z plane
     */
    virtual int getNumXY(int z) = 0;

    /// method to calculate the stencil at a boundary points
    /// \param x index of the current element in the matrix
    /// \param y index of the current element in the matrix
    /// \param z index of the current element in the matrix
    /// \param W stencil value of the element in the west of idx: (x-1)
    /// \param E stencil value of the element in the east of idx: (x+1)
    /// \param S stencil value of the element in the south of idx: (y-1)
    /// \param N stencil value of the element in the north of idx: (y+1)
    /// \param F stencil value of the element in front of idx: (z-1)
    /// \param B stencil value of the element in the back of idx: (z+1)
    /// \param C stencil value of the element in the center
    virtual void getBoundaryStencil(int x, int y, int z, double &W, double &E, double &S, double &N, double &F, double &B, double &C, double &scaleFactor) = 0;

    /// method to calculate the stencil at a boundary points
    /// \param idx index of the current element in the matrix
    /// \param W stencil value of the element in the west of idx: (x-1)
    /// \param E stencil value of the element in the east of idx: (x+1)
    /// \param S stencil value of the element in the south of idx: (y-1)
    /// \param N stencil value of the element in the north of idx: (y+1)
    /// \param F stencil value of the element in front of idx: (z-1)
    /// \param B stencil value of the element in the back of idx: (z+1)
    /// \param C stencil value of the element in the center
    virtual void getBoundaryStencil(int idx, double &W, double &E, double &S, double &N, double &F, double &B, double &C, double &scaleFactor) = 0;

    /// method to calculate the neighbours in the matrix of the current index (x,y,z)
    /// \param x index of the current element in the matrix
    /// \param y index of the current element in the matrix
    /// \param z index of the current element in the matrix
    /// \param W stencil index of the element in the west of idx: (x-1)
    /// \param E stencil index of the element in the east of idx: (x+1)
    /// \param S stencil index of the element in the south of idx: (y-1)
    /// \param N stencil index of the element in the north of idx: (y+1)
    /// \param F stencil index of the element in front of idx: (z-1)
    /// \param B stencil index of the element in the back of idx: (z+1)
    virtual void getNeighbours(int x, int y, int z, int &W, int &E, int &S, int &N, int &F, int &B) = 0;
    virtual void getNeighbours(int idx, int &W, int &E, int &S, int &N, int &F, int &B) = 0;

    /// method that identifies a specialized boundary geometry
    /// \return std::string containing a description of the boundary geometry used
    virtual std::string getType() = 0;

    /// method that checks if a given point lies inside the boundary
    /// \param x index of the current element in the matrix
    /// \param y index of the current element in the matrix
    /// \param z index of the current element in the matrix
    /// \return boolean indicating if the point lies inside the boundary
    virtual bool isInside(int x, int y, int z) = 0;

    Vector_t getNr() { return nr; }
    Vector_t getHr() { return hr; }
    void setNr(Vector_t nri) { nr = nri; }
    void setHr(Vector_t hri) { hr = hri; }

    void setMinMaxZ(double minz, double maxz) { zMin_m=minz; zMax_m=maxz; }
    double getMinZ() { return zMin_m; }
    double getMaxZ() { return zMax_m; }

112 113
    void setGlobalMeanR(Vector_t rmean) { rMean_m = rmean;}
    Vector_t getGlobalMeanR() { return rMean_m; }
114

115 116 117
    void setGlobalToLocalQuaternion(Quaternion_t globalToLocalQuaternion){
        globalToLocalQuaternion_m = globalToLocalQuaternion;}
    Quaternion_t getGlobalToLocalQuaternion() { return globalToLocalQuaternion_m;}
118

gsell's avatar
gsell committed
119 120 121 122
    virtual double getXRangeMin() = 0;
    virtual double getXRangeMax() = 0;
    virtual double getYRangeMin() = 0;
    virtual double getYRangeMax() = 0;
123 124
    virtual double getZRangeMin() = 0;
    virtual double getZRangeMax() = 0;
gsell's avatar
gsell committed
125 126 127

    virtual int getIdx(int x, int y, int z) = 0;
    virtual bool hasGeometryChanged() = 0;
128
    virtual ~IrregularDomain() {};
gsell's avatar
gsell committed
129

130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
    // FIXME The function body should be implemented in derived classes.
    virtual void resizeMesh(Vector_t& origin, Vector_t& hr, PartBunchBase<double, 3>* /*bunch*/) {
        double xmin = getXRangeMin();
        double xmax = getXRangeMax();
        double ymin = getYRangeMin();
        double ymax = getYRangeMax();
        double zmin = getZRangeMin();
        double zmax = getZRangeMax();

        origin = Vector_t(xmin, ymin , zmin);
        Vector_t mymax = Vector_t(xmax, ymax , zmax);

        for (int i = 0; i < 3; i++)
            hr[i]   = (mymax[i] - origin[i]) / nr[i];
    };

gsell's avatar
gsell committed
146 147 148 149 150 151 152 153 154 155 156
protected:

    // a irregular domain is always defined on a grid
    /// number of mesh points in each direction
    Vector_t nr;
    /// mesh-spacings in each direction
    Vector_t hr;

    /// min/max of bunch in floor coordinates
    double zMin_m;
    double zMax_m;
157 158 159

    /// mean position of bunch (m)
    Vector_t rMean_m;
160
    Quaternion_t globalToLocalQuaternion_m;
gsell's avatar
gsell committed
161 162
};

163 164 165 166 167 168 169 170 171
#endif

// vi: set et ts=4 sw=4 sts=4:
// Local Variables:
// mode:c
// c-basic-offset: 4
// indent-tabs-mode: nil
// require-final-newline: nil
// End: