Mercurial > repos > public > sbplib_julia

annotate Notes.md @ 1734:2311f33b6bd3 cleanup

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Delete submodule DiffOps
author Jonatan Werpers <jonatan@werpers.com>
date Tue, 10 Sep 2024 20:42:41 +0200
parents 52c2e6dff228
children fe058a0ebd97
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
318
0c8d4a734c4f Add some todos and add a Notes.md file
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
1 # Notes
0c8d4a734c4f Add some todos and add a Notes.md file
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
2
1610
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
3 ## How to dispatch for different operators
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
4 We have a problem in how dispatch for different operators work.
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
5 * We want to keep the types simple and flat (Awkward to forward `apply`)
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
6 * We want to dispatch SATs on the parameters of the continuous operator. (a * div for example)
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
7 * We want to allow keeping the same stencil_set across different calls. (maybe not so bad for the user to be responsible)
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
8
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
9 Could remove the current opset idea and introduce a description of continuous operators
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
10 ```julia
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
11 abstract type DifferentialOperator end
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
12
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
13 struct Laplace <: DifferentialOperator end
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
14 struct Advection <: DifferentialOperator
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
15 v
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
16 end
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
17
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
18 difference_operator(::Laplace, grid, stencil_set) = ... # Returns a plain LazyTensor. Replaces the current `laplace()` function.
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
19 sat_tensors(::Laplace, grid, stencil_set, bc) = ...
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
20
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
21 sat(::DifferentialOperator, grid, stencil_set, bc) = ...
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
22 ```
bb4c119e91fa Add note about idea for how to handle dispatch and continuous operators
Jonatan Werpers <jonatan@werpers.com>
parents: 1546
diff changeset
23
1643
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
24
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
25 ### Update 2024-06-26
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
26 We will run into trouble if we start assuming things about the coupling
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
27 between the continuous and discrete setting. We could add representations of
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
28 continuous operators but we will also need representations of discrete
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
29 operators. Ideally it should be possible to ignore the continuous
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
30 representations and only work with the discrete operators without losing
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
31 functionality. The discrete representations does not have to be LazyTensors.
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
32 The could be used as inputs to methods for `sat`, `difference_operator` and so
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
33 on.
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
34
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
35 To see need for a fully functional discrete layer we can consider the
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
36 optimization of material parameters or something similar. In this case we do
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
37 not necessarily want to handle continuous objects.
e551fe1fff14 More notes on operator representations
Jonatan Werpers <jonatan@werpers.com>
parents: 1621
diff changeset
38
654
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
39 ## Reading operators
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
40
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
41 Jonatan's suggestion is to add methods to `Laplace`, `SecondDerivative` and
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
42 similar functions that take in a filename from which to read stencils. These
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
43 methods encode how to use the structure in a file to build the particular
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
44 operator. The filename should be a keyword argument and could have a default
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
45 value.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
46
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
47 * This allows easy creation of operators without the user having to handle stencils.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
48 * The user can easily switch between sets of operators by changing the file stecils are read from.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
49
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
50 Grids for optimized operators could be created by reading from a .toml file in
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
51 a similar fashion as for the operators. The grid can then be used in a
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
52 `Laplace` method which dispatches on the grid type and knows how to read the
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
53 optimized operators. The method would also make sure the operators match the
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
54 grid.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
55
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
56 Idea: Make the current upper case methods lower case. Add types with the upper
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
57 case names. These types are tensor mappings for the operator but also contain
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
58 the associated operators as fields. For example:
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
59
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
60 ```julia
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
61 L = Laplace(grid)
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
62 L.H
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
63 L.Hi
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
64 L.e
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
65 L.d
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
66 L.M
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
67
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
68 wave = L - L.Hi∘L.e'∘L.d
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
69 ```
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
70
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
71 These types could also contain things like borrowing and such.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
72
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
73 ## Storage of operators
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
74 We need to change the toml format so that it is easier to store several
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
75 operator with different kinds of differentiations. For example there could be
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
76 several operators of the same order but with different number of boundary
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
77 points or different choice of boundary stencils.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
78
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
79 Properties that differentiate operators should for this reason be stored in
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
80 variables and not be section or table names.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
81
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
82 Operators/sets of stencils should be stored in an [array of tables](https://toml.io/en/v1.0.0-rc.3#array-of-tables).
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
83
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
84 We should formalize the format and write simple and general access methods for
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
85 getting operators/sets of stencils from the file. They should support a simple
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
86 way to filter based on values of variables. There filters could possibly be
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
87 implemented through keyword arguments that are sent through all the layers of
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
88 operator creation.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
89
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
90 * Remove order as a table name and put it as a variable.
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
91
853
fe8fe3f01162 Docs touch up
Jonatan Werpers <jonatan@werpers.com>
parents: 829
diff changeset
92 ### Parsing of stencil sets
829
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
93 At the moment the only parsing that can be done at the top level is conversion
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
94 from the toml file to a dict of strings. This forces the user to dig through
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
95 the dictionary and apply the correct parsing methods for the different parts,
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
96 e.g. `parse_stencil` or `parse_tuple`. While very flexible there is a tight
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
97 coupling between what is written in the file and what code is run to make data
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
98 in the file usable. While this coupling is hard to avoid it should be made
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
99 explicit. This could be done by putting a reference to a parsing function in
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
100 the operator-storage format or somehow specifying the type of each object.
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
101 This mechanism should be extensible without changing the package. Perhaps
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
102 there could be a way to register parsing functions or object types for the
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
103 toml.
1de10f5b2008 Add some notes on the format of operator storage
Jonatan Werpers <jonatan@werpers.com>
parents: 775
diff changeset
104
853
fe8fe3f01162 Docs touch up
Jonatan Werpers <jonatan@werpers.com>
parents: 829
diff changeset
105 If possible the goal should be for the parsing to get all the way to the
fe8fe3f01162 Docs touch up
Jonatan Werpers <jonatan@werpers.com>
parents: 829
diff changeset
106 stencils so that a user calls `read_stencil_set` and gets a
fe8fe3f01162 Docs touch up
Jonatan Werpers <jonatan@werpers.com>
parents: 829
diff changeset
107 dictionary-structure containing stencils, tuples, scalars and other types
fe8fe3f01162 Docs touch up
Jonatan Werpers <jonatan@werpers.com>
parents: 829
diff changeset
108 ready for input to the methods creating the operators.
654
d26231227b89 Add a bunch of notes on reading and storing operators and how to implement variable second derivatives
Jonatan Werpers <jonatan@werpers.com>
parents: 606
diff changeset
109
318
0c8d4a734c4f Add some todos and add a Notes.md file
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
110 ## Known size of range and domain?
320
d705b397aa33 Clean up Notes.md and TODO.md
Jonatan Werpers <jonatan@werpers.com>
parents: 319
diff changeset
111 Is there any reason to use a trait to differentiate between fixed size and unknown size?
d705b397aa33 Clean up Notes.md and TODO.md
Jonatan Werpers <jonatan@werpers.com>
parents: 319
diff changeset
112
379
de4746d6d126 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 332
diff changeset
113 When do we need to know the size of the range and domain?
de4746d6d126 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 332
diff changeset
114 * When indexing to provide boundschecking?
de4746d6d126 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 332
diff changeset
115 * When doing specialised computations for different parts of the range/domain?
de4746d6d126 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 332
diff changeset
116 * More?
319
05ac7d7f9176 Move research and thinking from TODO.md to Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 318
diff changeset
117
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
118 Maybe if we should have dynamic sizing it could be only for the range. `domain_size` would not be implemented. And the `range_size` would be a function of a vector that the LazyTensor is applied to.
332
535f1bff4bcc Add some notes and some todos
Jonatan Werpers <jonatan@werpers.com>
parents: 320
diff changeset
119
319
05ac7d7f9176 Move research and thinking from TODO.md to Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 318
diff changeset
120 ## Reasearch and thinking
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
121 - [ ] Use a trait to indicate that a LazyTensor har the same range and domain?
319
05ac7d7f9176 Move research and thinking from TODO.md to Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 318
diff changeset
122 - [ ] Check how the native julia doc generator works
05ac7d7f9176 Move research and thinking from TODO.md to Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 318
diff changeset
123 - [ ] Check if Vidars design docs fit in there
05ac7d7f9176 Move research and thinking from TODO.md to Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 318
diff changeset
124 - [ ] Create a macro @lazy which replaces a binary op (+,-) by its lazy equivalent? Would be a neat way to indicate which evaluations are lazy without cluttering/confusing with special characters.
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
125 - [ ] Dispatch on Lower() instead of the type Lower so `::Lower` instead of `::Type{Lower}` ???
332
535f1bff4bcc Add some notes and some todos
Jonatan Werpers <jonatan@werpers.com>
parents: 320
diff changeset
126 Seems better unless there is some specific reason to use the type instead of the value.
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
127 - [ ] Can we have a trait to tell if a LazyTensor is transposable?
379
de4746d6d126 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 332
diff changeset
128 - [ ] Is it ok to have "Constructors" for abstract types which create subtypes? For example a Grids() functions that gives different kind of grids based on input?
663
f1803ab08740 Add Note on how we should treat the borrowing parameters of operators.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 654
diff changeset
129 - [ ] Figure out how to treat the borrowing parameters of operators. Include in into the struct? Expose via function dispatched on the operator type and grid?
410
26e186b565b3 Add some notes about vector valued grid functions
Jonatan Werpers <jonatan@werpers.com>
parents: 379
diff changeset
130
1050
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
131 ## Identifiers for regions
1674
52c2e6dff228 Revert changes to Notes.md (accidentaly commited)
Vidar Stiernström <vidar.stiernstrom@gmail.com>
parents: 1672
diff changeset
132 The identifiers (`Upper`, `Lower`, `Interior`) used for region indecies should probably be included in the grid module. This allows new grid types to come with their own regions.
52c2e6dff228 Revert changes to Notes.md (accidentaly commited)
Vidar Stiernström <vidar.stiernstrom@gmail.com>
parents: 1672
diff changeset
133 We implement this by refactoring RegionIndices to be agnostic to the region types and then moving the actual types to Grids.
1050
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
134
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
135 ## Regions and tensormappings
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
136 - [ ] Use a trait to indicate if a LazyTensor uses indices with regions.
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
137 The default should be that they do NOT.
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
138 - [ ] What to name this trait? Can we call it IndexStyle but not export it to avoid conflicts with Base.IndexStyle?
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
139 - [ ] Figure out repeated application of regioned LazyTensors. Maybe an instance of a tensor mapping needs to know the exact size of the range and domain for this to work?
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
140
1050
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
141 ### Ideas for information sharing functions
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
142 ```julia
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
143 using StaticArrays
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
144
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
145 function regions(op::SecondDerivativeVariable)
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
146 t = ntuple(i->(Interior(),),range_dim(op))
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
147 return Base.setindex(t, (Lower(), Interior(), Upper()), derivative_direction(op))
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
148 end
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
149
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
150 function regionsizes(op::SecondDerivativeVariable)
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
151 sz = tuple.(range_size(op))
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
152
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
153 cl = closuresize(op)
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
154 return Base.setindex(sz, (cl, n-2cl, cl), derivative_direction(op))
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
155 end
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
156
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
157
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
158 g = EquidistantGrid((11,9), (0.,0.), (10.,8.)) # h = 1
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
159 c = evalOn(g, (x,y)->x+y)
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
160
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
161 D₂ᶜ = SecondDerivativeVariable(g, c, interior_stencil, closure_stencils,1)
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
162 @test regions(D₂ᶜ) == (
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
163 (Lower(), Interior(), Upper()),
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
164 (Interior(),),
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
165 )
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
166 @test regionsizes(D₂ᶜ) == ((1,9,1),(9,))
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
167
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
168
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
169 D₂ᶜ = SecondDerivativeVariable(g, c, interior_stencil, closure_stencils,2)
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
170 @test regions(D₂ᶜ) == (
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
171 (Interior(),),
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
172 (Lower(), Interior(), Upper()),
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
173 )
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
174 @test regionsizes(D₂ᶜ) == ((11,),(1,7,1))
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
175 ```
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
176
396278072f18 Add some notes and clean up TODO.md a little bit
Jonatan Werpers <jonatan@werpers.com>
parents: 1041
diff changeset
177
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
178 ## Boundschecking and dimension checking
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
179 Does it make sense to have boundschecking only in getindex methods?
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
180 This would mean no bounds checking in applys, however any indexing that they do would be boundschecked. The only loss would be readability of errors. But users aren't really supposed to call apply directly anyway.
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
181
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
182 Preferably dimensions and sizes should be checked when lazy objects are created, for example TensorApplication, TensorComposition and so on. If dimension checks decreases performance we can make them skippable later.
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
183
1342
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
184 ## Changes to `eval_on`
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
185 There are reasons to replace `eval_on` with regular `map` from Base, and implement a kind of lazy map perhaps `lmap` that work on indexable collections.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
186
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
187 The benefit of doing this is that we can treat grids as gridfunctions for the coordinate function, and get a more flexible tool. For example `map`/`lmap` can then be used both to evaluate a function on the grid but also get a component of a vector valued grid function or similar.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
188
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
189 A question is how and if we should implement `map`/`lmap` for functions like `(x,y)->x*y` or stick to just using vector inputs. There are a few options.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
190
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
191 * use `Base.splat((x,y)->x*y)` with the single argument `map`/`lmap`.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
192 * implement a kind of `unzip` function to get iterators for each component, which can then be used with the multiple-iterators-version of `map`/`lmap`.
1347
08f06bfacd5c Fix typos and formatting of documentation
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 1345
diff changeset
193 * Inspect the function in the `map`/`lmap` function to determine which matches.
1342
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
194
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
195 Below is a partial implementation of `lmap` with some ideas
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
196 ```julia
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
197 struct LazyMapping{T,IT,F}
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
198 f::F
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
199 indexable_iterator::IT # ___
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
200 end
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
201
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
202 function LazyMapping(f,I)
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
203 IT = eltype(I)
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
204 T = f(zero(T))
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
205 F = typeof(f)
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
206
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
207 return LazyMapping{T,IT,F}(f,I)
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
208 end
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
209
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
210 getindex(lm::LazyMapping, I...) = lm.f(lm.I[I...])
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
211 # indexabl interface
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
212 # iterable has shape
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
213
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
214 iterate(lm::LazyMapping) = _lazy_mapping_iterate(lm, iterate(lm.I))
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
215 iterate(lm::LazyMapping, state) = _lazy_mapping_iterate(lm, iterate(lm.I, state))
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
216
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
217 _lazy_mapping_iterate(lm, ::Nothing) = nothing
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
218 _lazy_mapping_iterate(lm, (next, state)) = lm.f(next), state
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
219
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
220 lmap(f, I) = LazyIndexableMap(f,I)
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
221 ```
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
222
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
223 The interaction of the map methods with the probable design of multiblock functions involving nested indecies complicate the picture slightly. It's clear at the time of writing how this would work with `Base.map`. Perhaps we want to implement our own versions of both eager and lazy map.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
224
1528
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
225
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
226 ### 2024-04
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
227 MappedArrays.jl provides a simple array type and function like the description
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
228 of LazyMapping above. One option is to remove `eval_on` completely and rely on
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
229 destructuring arguments if handling the function input as a vector is
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
230 undesirable.
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
231
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
232 If we can let multi-block grids be iterators over grid points we could even
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
233 handle those by specialized implementation of `map` and `mappedarray`.
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
234
1342
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
235 ## Multiblock implementation
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
236 We want multiblock things to work very similarly to regular one block things.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
237
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
238 ### Grid functions
1528
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
239 Should probably support a nested indexing so that we first have an index for
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
240 subgrid and then an index for nodes on that grid. E.g `g[1,2][2,3]` or
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
241 `g[3][43,21]`.
1342
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
242
1528
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
243 We could also possibly provide a combined indexing style `g[1,2,3,4]` where
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
244 the first group of indices are for the subgrid and the remaining are for the
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
245 nodes.
1342
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
246
1528
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
247 We should make sure the underlying buffer for grid functions are continuously
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
248 stored and are easy to convert to, so that interaction with for example
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
249 DifferentialEquations is simple and without much boilerplate.
1342
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
250
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
251 #### `map` and `collect` and nested indexing
1528
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
252 We need to make sure `collect`, `map` and a potential lazy map work correctly
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
253 through the nested indexing. Also see notes on `eval_on` above.
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
254
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
255 Possibly this can be achieved by providing special nested indexing but not
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
256 adhering to an array interface at the top level, instead being implemented as
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
257 an iterator over the grid points. A custom trait can let map and other methods
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
258 know the shape (or structure) of the nesting so that they can efficiently
d641798539c2 Update notes on changes to `eval_on` and multiblock grids
Jonatan Werpers <jonatan@werpers.com>
parents: 1469
diff changeset
259 allocate result arrays.
1342
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
260
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
261 ### Tensor applications
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
262 Should behave as grid functions
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
263
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
264 ### LazyTensors
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
265 Could be built as a tuple or array of LazyTensors for each grid with a simple apply function.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
266
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
267 Nested indexing for these is problably not needed unless it simplifies their own implementation.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
268
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
269 Possibly useful to provide a simple type that doesn't know about connections between the grids. Antother type can include knowledge of the.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
270
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
271 We have at least two option for how to implement them:
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
272 * Matrix of LazyTensors
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
273 * Looking at the grid and determining what the apply should do.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
274
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
275 ### Overall design implications of nested indices
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
276 If some grids accept nested indexing there might be a clash with how LazyArrays work. It would be nice if the grid functions and lazy arrays that actually are arrays can be AbstractArray and things can be relaxed for nested index types.
c0c1189c5f2e Clean up grid_refactor.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1326
diff changeset
277
410
26e186b565b3 Add some notes about vector valued grid functions
Jonatan Werpers <jonatan@werpers.com>
parents: 379
diff changeset
278 ## Vector valued grid functions
423
10a67ac48d6e Add some notes
Jonatan Werpers <jonatan@werpers.com>
parents: 410
diff changeset
279
10a67ac48d6e Add some notes
Jonatan Werpers <jonatan@werpers.com>
parents: 410
diff changeset
280 ### Test-applikationer
1326
e352630a0309 Fix a bunch of typos
Jonatan Werpers <jonatan@werpers.com>
parents: 1290
diff changeset
281 div- och grad-operationer
423
10a67ac48d6e Add some notes
Jonatan Werpers <jonatan@werpers.com>
parents: 410
diff changeset
282
1326
e352630a0309 Fix a bunch of typos
Jonatan Werpers <jonatan@werpers.com>
parents: 1290
diff changeset
283 Enligt Wikipedia verkar det som att `∇⋅` agerar på första dimensionen av ett tensorfält och `div()` på sista.
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
284 Om man generaliserar kanske `∇` i så fall bara lägger till en dimension i början.
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
285
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
286 Kan vi implementera `⋅`(\cdot) så att de fungerar som man vill för både tensor-fält och tensor-operatorer?
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
287
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
288 Är `∇` ett tensor-fält av tensor-operatorer? Vad är ett tensor-fält i vår kod? Är det en special-fall av en tensor-mapping?
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
289
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
290 ### Grid-funktionen
1326
e352630a0309 Fix a bunch of typos
Jonatan Werpers <jonatan@werpers.com>
parents: 1290
diff changeset
291 Grid-funktioner har typen `AbstractArray{T,2} where T`.
e352630a0309 Fix a bunch of typos
Jonatan Werpers <jonatan@werpers.com>
parents: 1290
diff changeset
292 `T` kan vara lite vad som helst, tillexemel en SVector eller Array, eller Tuple. Tensoroperatorerna bryr sig inte om exakt vad det är, mer än att typen måste stödja de operationer som operatorn använder.
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
293
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
294 En nackdel kan vara hur man ska få ut gridfunktionen för tex andra komponenten.
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
295
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
296 Syntax:
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
297 ```
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
298 f(x̄) = x̄
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
299 gf = evalOn(g, f)
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
300 gf[2,3] # x̄ för en viss gridpunkt
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
301 gf[2,3][2] # x̄[2] för en viss gridpunkt
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
302 ```
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
303
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
304 ### Tensor operatorer
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
305 Vi kan ha tensor-operatorer som agerar på ett skalärt fält och ger ett vektorfält eller tensorfält.
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
306 Vi kan också ha tensor-operatorer som agerar på ett vektorfält eller tensorfält och ger ett skalärt fält.
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
307
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
308 TBD: Just nu gör `apply_transpose` antagandet att domän-typen är samma som range-typen. Det behöver vi på något sätt bryta. Ett alternativ är låta en LazyTensor ha `T_domain` och `T_range` istället för bara `T`. Känns dock lite grötigt. Ett annat alternativ skulle vara någon typ av trait för transpose? Den skulle kunna innehålla typen som transponatet agerar på? Vet inte om det fungerar dock.
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
309
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
310 TBD: Vad är målet med `T`-parametern för en LazyTensor? Om vi vill kunna applicera en difference operator på vad som helst kan man inte anta att en `LazyTensor{T}` bara agerar på instanser av `T`.
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
311
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
312 Man kan implementera `∇` som en tensormapping som agerar på T och returnerar `StaticVector{N,T} where N`.
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
313 (Man skulle eventuellt också kunna låta den agera på `StaticMatrix{N,T,D} where N` och returnera `StaticMatrix{M,T,D+1}`. Frågan är om man vinner något på det...)
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
314
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
315 Skulle kunna ha en funktion `range_type(::LazyTensor, ::Type{domain_type})`
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
316
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
317 Kanske kan man implementera `⋅(tm::LazyTensor{R,D}, v::AbstractArray{T,D})` där T är en AbstractArray, tm på något sätt har komponenter, lika många som T har element.
606
8f9b3eac128a Add a bunch of stuff to TODO.md and Notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 427
diff changeset
318
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
319 ### Komponenter som gridfunktioner
1326
e352630a0309 Fix a bunch of typos
Jonatan Werpers <jonatan@werpers.com>
parents: 1290
diff changeset
320 En viktig operation för vektorfält är att kunna få ut komponenter som grid-funktioner. Detta behöver antagligen kunna ske lazy.
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
321 Det finns ett par olika lösningar:
1345
c2012db881cb Clean notes.md
Jonatan Werpers <jonatan@werpers.com>
parents: 1342
diff changeset
322 * Använda map eller en lazy map (se diskussion om eval_on)
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
323 * Implementera en egen typ av view som tar hand om detta. Eller Accessors.jl?
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
324 * Använda en LazyTensor
427
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
325 * Någon typ av lazy-broadcast
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
326 * En lazy array som applicerar en funktion för varje element.
1c41f4fd3e61 Add some notes and todos
Jonatan Werpers <jonatan@werpers.com>
parents: 423
diff changeset
327
683
841ca12f3359 Add notes about embedded grids
Jonatan Werpers <jonatan@werpers.com>
parents: 654
diff changeset
328
1286
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
329 ### Prestanda-aspekter
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
330 [Vidar, Discord, 2023-03-03]
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
331 Typiskt sett finns det två sätt att representera vektorvärda gridfunktioner AbstractArray{T,Dim} där T är en vektor över komponenterna. Man skulle alltså i 1D ha
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
332 u = [ [u1[x1], u2[x1]] , [u1[x2], u2[x2]], ... [u1[xN], u2[xN]]]. Detta brukar kallas array of structs (AoS). Alternativet är struct of arrays (SoA), där man har alla gridpunkter för en given komponent u = [[u1[x1], u1[x2]],... u1[xN]], [u2[x1], u2[x2], ... u2[xN]]].
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
333
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
334 Personligen tycker jag att AoS känns som den mer naturliga representationen? Det skulle göra det enklarare att parallelisera en vektorvärd gridfunktion över gridpunkterna, och om man opererar på olika komponenter i samma funktion så är det också bra ur en minnesaccess-synpunkt då dessa kommer ligga nära vandra i minnet. Problemet är att AoS sabbar vektorisering på CPU då två gridpunkter i en komponent ligger långt bort från varandra. Efter lite eftersökningar (och efter att snackat lite med Ossian) så verkar det ändå som att AoS är dåligt på GPU, där man vill att trådar typiskt sett utföra samma operation på närliggande minne.
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
335
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
336 Vad tänker du kring detta ur ett interface-perspektiv? Jag hittade paketet https://github.com/JuliaArrays/StructArrays.jl som verkar erbjuda AoS-interface men SoA-minneslayout så det kanske kan vara något vi kan använda? Inte native-stödd på samma sätt som SVector, men verkar iaf utvecklas aktivt.
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
337
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
338 [Efter telefonsamtal] För optimal prestanda behöver vi antagligen se till att man kan räkna ut varje komponent i en punkt individuellt. Detta så att man har frihet att till exempel låta den innersta loopen hålla komponentindexet konstant för att underlätta intruktionsvektorisering.
23f3b62388ba Add some notes about grid functions:
Jonatan Werpers <jonatan@werpers.com>
parents: 1277
diff changeset
339
1290
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
340
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
341 [Vidare tankar]
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
342 * Det borde bara vara output-gridfunktionen som behöver special-indexeras? Det viktiga på inputsidan är att den är lagrad på rätt sätt i minnet.
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
343 * Det borde inte vara några problem att behålla det "optimala" interfacet (gf[1,1,1][2]) till gridfunktionerna. Om man verkligen behöver kan skapa parallella indexeringsmetoder som gör det man behöver, i.e, "deep indexing".
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
344 * Det är inte säkert att vi behöver göra något speciellt på outputsidan överhuvudtaget. Det känns inte orimligt att kompilatorn skulle kunna optimera bort den koden som räknar ut onödiga komponenter.
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
345 * Om vi behöver special-indexering kommer till exempel LazyTensorApplication att behöva implementera det.
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
346 * För att komma vidare med något mer avancerat behöver vi antagligen implementera några operatorer som ger och agerar på vektorvärda funktioner. Tex grad, elastiska operatorn, andra?
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
347
31d0b7638304 More notes
Jonatan Werpers <jonatan@werpers.com>
parents: 1286
diff changeset
348
718
05d8ea88c690 Add note about performance testin
Jonatan Werpers <jonatan@werpers.com>
parents: 683
diff changeset
349 ## Performance measuring
05d8ea88c690 Add note about performance testin
Jonatan Werpers <jonatan@werpers.com>
parents: 683
diff changeset
350 We should be measuring performance early. How does our effective cpu and memory bandwidth utilization compare to peak performance?
05d8ea88c690 Add note about performance testin
Jonatan Werpers <jonatan@werpers.com>
parents: 683
diff changeset
351
05d8ea88c690 Add note about performance testin
Jonatan Werpers <jonatan@werpers.com>
parents: 683
diff changeset
352 We should make these test simple to run for any solver.
05d8ea88c690 Add note about performance testin
Jonatan Werpers <jonatan@werpers.com>
parents: 683
diff changeset
353
05d8ea88c690 Add note about performance testin
Jonatan Werpers <jonatan@werpers.com>
parents: 683
diff changeset
354 See [this talk](https://www.youtube.com/watch?v=vPsfZUqI4_0) for some simple ideas for defining effecive memory usage and some comparison with peak performance.
05d8ea88c690 Add note about performance testin
Jonatan Werpers <jonatan@werpers.com>
parents: 683
diff changeset
355
05d8ea88c690 Add note about performance testin
Jonatan Werpers <jonatan@werpers.com>
parents: 683
diff changeset
356
761
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
357 ## Adjoint as a trait on the sbp_operator level?
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
358
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
359 It would be nice to have a way of refering to adjoints with resepct to the sbp-inner-product.
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
360 If it was possible you could reduce the number of times you have to deal with the inner product matrix.
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
361
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
362 Since the LazyOperators package is sort of implementing matrix-free matrices there is no concept of inner products there at the moment. It seems to complicate large parts of the package if this was included there.
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
363
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
364 A different approach would be to include it as a trait for operators so that you can specify what the adjoint for that operator is.
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
365
d7d030f8f708 Add note about adjoint as trait
Jonatan Werpers <jonatan@werpers.com>
parents: 718
diff changeset
366
775
1d166e7a9deb Add a note about the name of VolumeOperator
Jonatan Werpers <jonatan@werpers.com>
parents: 761
diff changeset
367 ## Name of the `VolumeOperator` type for constant stencils
995
1ba8a398af9c Rename types
Jonatan Werpers <jonatan@werpers.com>
parents: 866
diff changeset
368 It seems that the name is too general. The name of the method `volume_operator` makes sense. It should return different types of `LazyTensor` specialized for the grid. A suggetion for a better name is `ConstantStencilVolumeOperator`
1224
e2f6dafb5d83 Add note about LazyOuterProduct
Jonatan Werpers <jonatan@werpers.com>
parents: 1050
diff changeset
369
e2f6dafb5d83 Add note about LazyOuterProduct
Jonatan Werpers <jonatan@werpers.com>
parents: 1050
diff changeset
370
e2f6dafb5d83 Add note about LazyOuterProduct
Jonatan Werpers <jonatan@werpers.com>
parents: 1050
diff changeset
371 ## Implementation of LazyOuterProduct
e2f6dafb5d83 Add note about LazyOuterProduct
Jonatan Werpers <jonatan@werpers.com>
parents: 1050
diff changeset
372 Could the implementation of LazyOuterProduct be simplified by making it a
e2f6dafb5d83 Add note about LazyOuterProduct
Jonatan Werpers <jonatan@werpers.com>
parents: 1050
diff changeset
373 struct containing two or more LazyTensors? (using split_tuple in a similar way
e2f6dafb5d83 Add note about LazyOuterProduct
Jonatan Werpers <jonatan@werpers.com>
parents: 1050
diff changeset
374 as TensorGrid)
1465
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
375
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
376 ## Implementation of boundary_indices for more complex grids
1469
54ae92803b0b Fix wording/typos
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 1468
diff changeset
377 To represent boundaries of for example tet-elements we can use a type `IndexCollection` to index a grid function directly.
1465
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
378
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
379 ```julia
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
380 I = IndexCollection(...)
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
381 v[I]
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
382 ```
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
383
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
384 * This would impact how tensor grid works.
88e738d807cb Implement boundary_indices for TensorGrid
Jonatan Werpers <jonatan@werpers.com>
parents: 1381
diff changeset
385 * To make things homogenous maybe these index collections should be used for the more simple grids too.
1469
54ae92803b0b Fix wording/typos
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 1468
diff changeset
386 * The function `to_indices` from Base could be useful to implement for `IndexCollection`
1546
8b9cdadb845a Add some comments
Jonatan Werpers <jonatan@werpers.com>
parents: 1528
diff changeset
387
8b9cdadb845a Add some comments
Jonatan Werpers <jonatan@werpers.com>
parents: 1528
diff changeset
388
8b9cdadb845a Add some comments
Jonatan Werpers <jonatan@werpers.com>
parents: 1528
diff changeset
389 ## Stencil application pipeline
8b9cdadb845a Add some comments
Jonatan Werpers <jonatan@werpers.com>
parents: 1528
diff changeset
390 We should make sure that `@inbounds` and `Base.@propagate_inbounds` are
8b9cdadb845a Add some comments
Jonatan Werpers <jonatan@werpers.com>
parents: 1528
diff changeset
391 applied correctly throughout the stack. When testing the performance of
8b9cdadb845a Add some comments
Jonatan Werpers <jonatan@werpers.com>
parents: 1528
diff changeset
392 stencil application on the bugfix/sbp_operators/stencil_return_type branch
8b9cdadb845a Add some comments
Jonatan Werpers <jonatan@werpers.com>
parents: 1528
diff changeset
393 there seemed to be some strange results where such errors could be the
8b9cdadb845a Add some comments
Jonatan Werpers <jonatan@werpers.com>
parents: 1528
diff changeset
394 culprit.
1734
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
395
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
396
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
397 ## Tiled loops and regions in apply
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
398 There should be easy ways to use functionalty splitting the application of a lazy array into regions and using tiled iteration. This could make the application more efficient by reducing branching and improving cache usage in the tight loop. On commit f215ac2a5c66 and before there were some early tests regarding this in a DiffOp submodule.
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
399
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
400 The main ideas were:
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
401 ```julia
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
402 function apply_region!(D::DiffOpCartesian{2}, u::AbstractArray{T,2}, v::AbstractArray{T,2}) where T
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
403 apply_region!(D, u, v, Lower, Lower)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
404 apply_region!(D, u, v, Lower, Interior)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
405 apply_region!(D, u, v, Lower, Upper)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
406 apply_region!(D, u, v, Interior, Lower)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
407 apply_region!(D, u, v, Interior, Interior)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
408 apply_region!(D, u, v, Interior, Upper)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
409 apply_region!(D, u, v, Upper, Lower)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
410 apply_region!(D, u, v, Upper, Interior)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
411 apply_region!(D, u, v, Upper, Upper)
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
412 return nothing
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
413 end
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
414 ```
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
415
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
416 ```julia
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
417 using TiledIteration
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
418 function apply_region_tiled!(D::DiffOpCartesian{2}, u::AbstractArray{T,2}, v::AbstractArray{T,2}, r1::Type{<:Region}, r2::Type{<:Region}) where T
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
419 ri = regionindices(D.grid.size, closuresize(D.op), (r1,r2))
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
420 # TODO: Pass Tilesize to function
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
421 for tileaxs ∈ TileIterator(axes(ri), padded_tilesize(T, (5,5), 2))
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
422 for j ∈ tileaxs[2], i ∈ tileaxs[1]
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
423 I = ri[i,j]
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
424 u[I] = apply(D, v, (Index{r1}(I[1]), Index{r2}(I[2])))
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
425 end
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
426 end
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
427 return nothing
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
428 end
2311f33b6bd3 Delete submodule DiffOps
Jonatan Werpers <jonatan@werpers.com>
parents: 1674
diff changeset
429 ```