dgtd/src/components/Sources.h at 9d67a345e37334b750c9ca0f1f6ddfb52bf81ced · OpenSEMBA/dgtd · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#pragma once

#include "Types.h"
#include "math/Function.h"

namespace maxwell {

class Source {
public:
	using Position = mfem::Vector;
	using Time = double;
	using Polarization = mfem::Vector;
	using Propagation = mfem::Vector;
	using CartesianAngles = mfem::Vector;

	virtual ~Source() = default;
	virtual std::unique_ptr<Source> clone() const = 0;

	virtual double eval(
		const Position&, const Time&,
		const FieldType&, const Direction&) const = 0;
};

class InitialField : public Source {
public:
	InitialField(
		const Function&,
		const FieldType&,
		const Polarization&,
		const Position& center,
		const CartesianAngles& angles = CartesianAngles({ 0.0,0.0,0.0 })
	);
	InitialField(const InitialField&);

	std::unique_ptr<Source> clone() const;

	double eval(
		const Position&, const Time&,
		const FieldType&, const Direction&) const;

	FieldType& fieldType() { return fieldType_; }
	Polarization& polarization() { return polarization_; }
	Function* magnitude() { return magnitude_.get(); }
	Position& center() { return center_; }

private:
	std::unique_ptr<Function> magnitude_;
	FieldType fieldType_{ E };
	Polarization polarization_;
	Position center_;
};

class Planewave : public Source {
public:
	Planewave(const Function&, const Polarization&, const Propagation&, const FieldType&);
	Planewave(const Planewave&);

	std::unique_ptr<Source> clone() const;

	double eval(
		const Position&, const Time&,
		const FieldType&, const Direction&) const;

private:
	std::unique_ptr<Function> magnitude_;
	Polarization polarization_;
	Propagation propagation_;
	FieldType fieldtype_;
};

class Sources {
public:
	Sources() = default;
	Sources(const Sources& rhs)
	{
		for (auto& v : rhs) {
			v_.push_back(v->clone());
		}
	}
	Sources(Sources&& rhs)
	{
		for (auto& v: rhs) {
			v_.push_back(std::move(v));
		}
	}
	Sources& operator=(const Sources& rhs)
	{
		for (auto& v : rhs) {
			v_.push_back(v->clone());
		}
		return *this;
	}
	Sources& operator=(Sources&& rhs)
	{
		{
			for (auto& v : rhs) {
				v_.push_back(std::move(v));
			}
		}
		return *this;
	}

	std::vector<std::unique_ptr<Source>>::const_iterator begin() const
	{
		return v_.cbegin();
	}

	std::vector<std::unique_ptr<Source>>::iterator begin()
	{
		return v_.begin();
	}

	std::vector<std::unique_ptr<Source>>::iterator end()
	{
		return v_.end();
	}

	std::vector<std::unique_ptr<Source>>::const_iterator end() const
	{
		return v_.cend();
	}

	Source* add(std::unique_ptr<Source>&& newV)
	{
		v_.push_back(std::move(newV));
		return v_.back().get();
	}

	Source* add(const Source& newV)
	{
		v_.push_back(newV.clone());
		return v_.back().get();
	}

	std::size_t size() const
	{
		return v_.size();
	}
private:
	std::vector<std::unique_ptr<Source>> v_;
};

}