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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
|
%global _empty_manifest_terminate_build 0
Name: python-lightweaver
Version: 0.8.2
Release: 1
Summary: Non-LTE Radiative Transfer Framework in Python
License: MIT
URL: http://github.com/Goobley/Lightweaver
Source0: https://mirrors.aliyun.com/pypi/web/packages/cd/30/a00503446da45a586063df51919a7cc547bf2cc89b4e608ed05860456a2e/lightweaver-0.8.2.tar.gz
Requires: python3-numpy
Requires: python3-scipy
Requires: python3-matplotlib
Requires: python3-numba
Requires: python3-parse
Requires: python3-specutils
Requires: python3-tqdm
Requires: python3-weno4
Requires: python3-pyyaml
%description
# Lightweaver
**C. Osborne (University of Glasgow) & I. Milić (NSO/CU Boulder), 2019-2021**
**MIT License**
Lightweaver is an NLTE radiative transfer code in the style of [RH](https://github.com/ITA-Solar/rh).
It is well validated against RH and also [SNAPI](https://github.com/ivanzmilic/snapi).
The code is currently designed for plane parallel atmospheres, either 1D single columns (which can be parallelised over wavelength) or 1.5D parallel columns with `ProcessPool` or MPI parallelisation.
There is also support for unpolarised radiative transfer in 2D atmospheres.
Lightweaver is described in a [paper (including examples!)](https://arxiv.org/abs/2107.00475), and has [API documentation](https://goobley.github.io/Lightweaver/).
Whilst the core numerics are implemented in C++, as much of the non-performance critical code as possible is implemented in Python, and the code currently only has a Python interface (provided through a Cython binding module).
Other languages with a C/C++ interface could interact directly with this core, hopefully allowing it to be reused as needed in different projects.
The aim of Lightweaver is to provide an NLTE Framework, rather than a "code".
That is to say, it should be more malleable, and provide easier access to experimentation, with most forms of experimentation (unless one wants to play with formal solvers or iteration schemes), being available directly from python.
Formal solvers that comply with the interface defined in Lightweaver can be compiled into separate shared libraries and then loaded at runtime.
The preceding concepts are inspired by the popular python machine learning frameworks such as PyTorch and Tensorflow.
## Installation
For most users precompiled python wheels (supporting modern Linux, Mac, and Windows 10 systems) can be installed from `pip` and are the easiest way to get started with Lightweaver.
Lightweaver requires python 3.8+, and it is recommended to be run inside a virtual environment using `conda`.
In this case a new virtual environment can be created with:
```
conda create -n Lightweaver python=3.8
```
activate the environment:
```
conda activate Lightweaver
```
and Lightweaver can then be installed with
```
python -m pip install lightweaver
```
### Installation from source
Whilst the above should work for most people, if you wish to work on the Lightweaver backend it is beneficial to have a source installation.
This requires a compiler supporting C++17.
The build is then run with `python3 -m pip install -vvv -e .`.
The libraries currently produce a few warnings, but should not produce any errors.
## Documentation
- [Paper](https://arxiv.org/abs/2107.00475).
- [API documentation](https://goobley.github.io/Lightweaver/).
- I suggest looking through [the samples repository](https://github.com/Goobley/LightweaverSamples) (in particular the `Simple*.py`) after the code description in the paper to gain an understanding of the basic functionality and interfaces.
These samples are unfortunately not always up to date, but are a work in progress.
- The [MsLightweaver repository](https://github.com/Goobley/MsLightweaver) contains a more "production grade" tool built on Lightweaver for reprocessing the time-dependent radiative output from RADYN simulations.
This tool is currently undocumented, but has a relatively simple structure.
Please contact me through this repository if difficulties are encountered.
## Acknowledgements
The [python implementation](https://github.com/jaimedelacruz/witt) of the Wittmann equation of state has been kindly provided J. de la Cruz Rodriguez.
%package -n python3-lightweaver
Summary: Non-LTE Radiative Transfer Framework in Python
Provides: python-lightweaver
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
BuildRequires: python3-cffi
BuildRequires: gcc
BuildRequires: gdb
%description -n python3-lightweaver
# Lightweaver
**C. Osborne (University of Glasgow) & I. Milić (NSO/CU Boulder), 2019-2021**
**MIT License**
Lightweaver is an NLTE radiative transfer code in the style of [RH](https://github.com/ITA-Solar/rh).
It is well validated against RH and also [SNAPI](https://github.com/ivanzmilic/snapi).
The code is currently designed for plane parallel atmospheres, either 1D single columns (which can be parallelised over wavelength) or 1.5D parallel columns with `ProcessPool` or MPI parallelisation.
There is also support for unpolarised radiative transfer in 2D atmospheres.
Lightweaver is described in a [paper (including examples!)](https://arxiv.org/abs/2107.00475), and has [API documentation](https://goobley.github.io/Lightweaver/).
Whilst the core numerics are implemented in C++, as much of the non-performance critical code as possible is implemented in Python, and the code currently only has a Python interface (provided through a Cython binding module).
Other languages with a C/C++ interface could interact directly with this core, hopefully allowing it to be reused as needed in different projects.
The aim of Lightweaver is to provide an NLTE Framework, rather than a "code".
That is to say, it should be more malleable, and provide easier access to experimentation, with most forms of experimentation (unless one wants to play with formal solvers or iteration schemes), being available directly from python.
Formal solvers that comply with the interface defined in Lightweaver can be compiled into separate shared libraries and then loaded at runtime.
The preceding concepts are inspired by the popular python machine learning frameworks such as PyTorch and Tensorflow.
## Installation
For most users precompiled python wheels (supporting modern Linux, Mac, and Windows 10 systems) can be installed from `pip` and are the easiest way to get started with Lightweaver.
Lightweaver requires python 3.8+, and it is recommended to be run inside a virtual environment using `conda`.
In this case a new virtual environment can be created with:
```
conda create -n Lightweaver python=3.8
```
activate the environment:
```
conda activate Lightweaver
```
and Lightweaver can then be installed with
```
python -m pip install lightweaver
```
### Installation from source
Whilst the above should work for most people, if you wish to work on the Lightweaver backend it is beneficial to have a source installation.
This requires a compiler supporting C++17.
The build is then run with `python3 -m pip install -vvv -e .`.
The libraries currently produce a few warnings, but should not produce any errors.
## Documentation
- [Paper](https://arxiv.org/abs/2107.00475).
- [API documentation](https://goobley.github.io/Lightweaver/).
- I suggest looking through [the samples repository](https://github.com/Goobley/LightweaverSamples) (in particular the `Simple*.py`) after the code description in the paper to gain an understanding of the basic functionality and interfaces.
These samples are unfortunately not always up to date, but are a work in progress.
- The [MsLightweaver repository](https://github.com/Goobley/MsLightweaver) contains a more "production grade" tool built on Lightweaver for reprocessing the time-dependent radiative output from RADYN simulations.
This tool is currently undocumented, but has a relatively simple structure.
Please contact me through this repository if difficulties are encountered.
## Acknowledgements
The [python implementation](https://github.com/jaimedelacruz/witt) of the Wittmann equation of state has been kindly provided J. de la Cruz Rodriguez.
%package help
Summary: Development documents and examples for lightweaver
Provides: python3-lightweaver-doc
%description help
# Lightweaver
**C. Osborne (University of Glasgow) & I. Milić (NSO/CU Boulder), 2019-2021**
**MIT License**
Lightweaver is an NLTE radiative transfer code in the style of [RH](https://github.com/ITA-Solar/rh).
It is well validated against RH and also [SNAPI](https://github.com/ivanzmilic/snapi).
The code is currently designed for plane parallel atmospheres, either 1D single columns (which can be parallelised over wavelength) or 1.5D parallel columns with `ProcessPool` or MPI parallelisation.
There is also support for unpolarised radiative transfer in 2D atmospheres.
Lightweaver is described in a [paper (including examples!)](https://arxiv.org/abs/2107.00475), and has [API documentation](https://goobley.github.io/Lightweaver/).
Whilst the core numerics are implemented in C++, as much of the non-performance critical code as possible is implemented in Python, and the code currently only has a Python interface (provided through a Cython binding module).
Other languages with a C/C++ interface could interact directly with this core, hopefully allowing it to be reused as needed in different projects.
The aim of Lightweaver is to provide an NLTE Framework, rather than a "code".
That is to say, it should be more malleable, and provide easier access to experimentation, with most forms of experimentation (unless one wants to play with formal solvers or iteration schemes), being available directly from python.
Formal solvers that comply with the interface defined in Lightweaver can be compiled into separate shared libraries and then loaded at runtime.
The preceding concepts are inspired by the popular python machine learning frameworks such as PyTorch and Tensorflow.
## Installation
For most users precompiled python wheels (supporting modern Linux, Mac, and Windows 10 systems) can be installed from `pip` and are the easiest way to get started with Lightweaver.
Lightweaver requires python 3.8+, and it is recommended to be run inside a virtual environment using `conda`.
In this case a new virtual environment can be created with:
```
conda create -n Lightweaver python=3.8
```
activate the environment:
```
conda activate Lightweaver
```
and Lightweaver can then be installed with
```
python -m pip install lightweaver
```
### Installation from source
Whilst the above should work for most people, if you wish to work on the Lightweaver backend it is beneficial to have a source installation.
This requires a compiler supporting C++17.
The build is then run with `python3 -m pip install -vvv -e .`.
The libraries currently produce a few warnings, but should not produce any errors.
## Documentation
- [Paper](https://arxiv.org/abs/2107.00475).
- [API documentation](https://goobley.github.io/Lightweaver/).
- I suggest looking through [the samples repository](https://github.com/Goobley/LightweaverSamples) (in particular the `Simple*.py`) after the code description in the paper to gain an understanding of the basic functionality and interfaces.
These samples are unfortunately not always up to date, but are a work in progress.
- The [MsLightweaver repository](https://github.com/Goobley/MsLightweaver) contains a more "production grade" tool built on Lightweaver for reprocessing the time-dependent radiative output from RADYN simulations.
This tool is currently undocumented, but has a relatively simple structure.
Please contact me through this repository if difficulties are encountered.
## Acknowledgements
The [python implementation](https://github.com/jaimedelacruz/witt) of the Wittmann equation of state has been kindly provided J. de la Cruz Rodriguez.
%prep
%autosetup -n lightweaver-0.8.2
%build
%py3_build
%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .
%files -n python3-lightweaver -f filelist.lst
%dir %{python3_sitearch}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Thu Jun 08 2023 Python_Bot <Python_Bot@openeuler.org> - 0.8.2-1
- Package Spec generated
|
