← Back to branch summary

~reducedmodelling/fluidity/ROM_Non-intrusive-ann

« back to all changes in this revision

Viewing changes to tests/burgers_mms_diffusion_time_integral/mms_B.bml

  • Committer: pef
  • Date: 2011-04-01 12:28:06 UTC
  • Revision ID: svn-v4:5bf5533e-7014-46e3-b1bb-cce4b9d03719:trunk:3428
Add another burgers equation MMS adjoint test.

This one tests something much harder to get right. The
functional is the spacetime integral of the velocity.
The simulation is engineered in such a way that the velocity
field is sin(x+t).

The first test is that the forward simulation is converging
at second-order in both space and time. (I don't know why
the group has this idea floating around that checking the temporal
order of convergence is hard; it's not.) The second test
is that the functional value is converging at second-order
to the true value.

The next test (to come) will check that the derivatives
computed with automatic differentiation give the same results
as those computed by hand.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/burgers_mms_diffusion_time_integral/mms_B.bml
 
1
<?xml version='1.0' encoding='utf8'?>
 
2
<burgers_equation>
 
3
  <simulation_name>
 
4
    <string_value lines="1">mms_diffusion_adjoint_B</string_value>
 
5
  </simulation_name>
 
6
  <geometry>
 
7
    <dimension>
 
8
      <integer_value rank="0">1</integer_value>
 
9
    </dimension>
 
10
    <mesh name="CoordinateMesh">
 
11
      <from_file file_name="mms_B">
 
12
        <format name="triangle"/>
 
13
        <stat>
 
14
          <include_in_stat/>
 
15
        </stat>
 
16
      </from_file>
 
17
    </mesh>
 
18
    <mesh name="VelocityMesh">
 
19
      <from_mesh>
 
20
        <mesh name="CoordinateMesh"/>
 
21
        <stat>
 
22
          <exclude_from_stat/>
 
23
        </stat>
 
24
      </from_mesh>
 
25
    </mesh>
 
26
    <quadrature>
 
27
      <degree>
 
28
        <integer_value rank="0">4</integer_value>
 
29
      </degree>
 
30
    </quadrature>
 
31
  </geometry>
 
32
  <io>
 
33
    <dump_format>vtk</dump_format>
 
34
    <dump_period_in_timesteps>
 
35
      <constant>
 
36
        <integer_value rank="0">1</integer_value>
 
37
      </constant>
 
38
    </dump_period_in_timesteps>
 
39
    <output_mesh name="VelocityMesh"/>
 
40
  </io>
 
41
  <timestepping>
 
42
    <current_time>
 
43
      <real_value rank="0">0.0</real_value>
 
44
    </current_time>
 
45
    <timestep>
 
46
      <real_value rank="0">1.0</real_value>
 
47
    </timestep>
 
48
    <finish_time>
 
49
      <real_value rank="0">10.0</real_value>
 
50
    </finish_time>
 
51
  </timestepping>
 
52
  <material_phase name="Fluid">
 
53
    <scalar_field name="Velocity" rank="0">
 
54
      <prognostic>
 
55
        <mesh name="VelocityMesh"/>
 
56
        <temporal_discretisation>
 
57
          <theta>
 
58
            <real_value rank="0">0.5</real_value>
 
59
          </theta>
 
60
          <relaxation>
 
61
            <real_value rank="0">0.5</real_value>
 
62
          </relaxation>
 
63
        </temporal_discretisation>
 
64
        <solver>
 
65
          <iterative_method name="gmres">
 
66
            <restart>
 
67
              <integer_value rank="0">30</integer_value>
 
68
            </restart>
 
69
          </iterative_method>
 
70
          <preconditioner name="sor"/>
 
71
          <relative_error>
 
72
            <real_value rank="0">1.0e-16</real_value>
 
73
          </relative_error>
 
74
          <absolute_error>
 
75
            <real_value rank="0">1.0e-12</real_value>
 
76
          </absolute_error>
 
77
          <max_iterations>
 
78
            <integer_value rank="0">10000</integer_value>
 
79
          </max_iterations>
 
80
          <never_ignore_solver_failures/>
 
81
          <diagnostics>
 
82
            <monitors/>
 
83
          </diagnostics>
 
84
        </solver>
 
85
        <remove_advection_term/>
 
86
        <initial_condition name="WholeMesh">
 
87
          <python>
 
88
            <string_value lines="20" type="python">def val(X, t):
 
89
  from math import sin
 
90
  x = X[0]
 
91
  return sin(x+t)</string_value>
 
92
          </python>
 
93
        </initial_condition>
 
94
        <boundary_conditions name="bc">
 
95
          <surface_ids>
 
96
            <integer_value shape="2" rank="1">1 2</integer_value>
 
97
          </surface_ids>
 
98
          <type name="dirichlet">
 
99
            <python>
 
100
              <string_value lines="20" type="python">def val(X, t):
 
101
  from math import sin
 
102
  x = X[0]
 
103
  return sin(x+t)</string_value>
 
104
            </python>
 
105
          </type>
 
106
        </boundary_conditions>
 
107
        <viscosity>
 
108
          <real_value rank="0">1.0</real_value>
 
109
        </viscosity>
 
110
        <stat/>
 
111
        <adjoint_storage>
 
112
          <exists_in_both/>
 
113
        </adjoint_storage>
 
114
        <scalar_field name="Source" rank="0">
 
115
          <prescribed>
 
116
            <value name="WholeMesh">
 
117
              <python>
 
118
                <string_value lines="20" type="python">def val(X, t):
 
119
  from math import sin, cos
 
120
  x = X[0]
 
121
  return sin(x+t) + cos(x+t)</string_value>
 
122
              </python>
 
123
            </value>
 
124
          </prescribed>
 
125
        </scalar_field>
 
126
      </prognostic>
 
127
    </scalar_field>
 
128
    <scalar_field name="AnalyticalSolution" rank="0">
 
129
      <prescribed>
 
130
        <mesh name="VelocityMesh"/>
 
131
        <value name="WholeMesh">
 
132
          <python>
 
133
            <string_value lines="20" type="python">def val(X, t):
 
134
  from math import sin
 
135
  x = X[0]
 
136
  return sin(x+t)</string_value>
 
137
          </python>
 
138
        </value>
 
139
        <adjoint_storage>
 
140
          <exists_in_forward/>
 
141
        </adjoint_storage>
 
142
      </prescribed>
 
143
    </scalar_field>
 
144
    <scalar_field name="Error" rank="0">
 
145
      <diagnostic>
 
146
        <mesh name="VelocityMesh"/>
 
147
        <algorithm name="scalar_python_diagnostic" material_phase_support="single">
 
148
          <string_value lines="20" type="python">soln = state.scalar_fields["Velocity"]
 
149
exact = state.scalar_fields["AnalyticalSolution"]
 
150
# The problem is only specified up to a constant, so add on the constant
 
151
constant = exact.node_val(0) - soln.node_val(0)
 
152
 
 
153
for i in range(field.node_count):
 
154
  field.set(i, soln.node_val(i) + constant - exact.node_val(i))</string_value>
 
155
        </algorithm>
 
156
        <stat/>
 
157
        <adjoint_storage>
 
158
          <exists_in_forward/>
 
159
        </adjoint_storage>
 
160
      </diagnostic>
 
161
    </scalar_field>
 
162
  </material_phase>
 
163
  <adjoint>
 
164
    <functional name="time_integral_ad">
 
165
      <functional_value>
 
166
        <algorithm name="functional_value">
 
167
          <string_value lines="20" type="python">import numpy
 
168
 
 
169
coord = states[0]["Fluid"].vector_fields["Coordinate"]
 
170
u = states[n]["Fluid"].scalar_fields["Velocity"]
 
171
u_prev = states[n-1]["Fluid"].scalar_fields["Velocity"]
 
172
int_u = 0.0
 
173
int_u_prev = 0.0
 
174
 
 
175
for ele in range(coord.element_count):
 
176
  t = Transform(ele, coord)
 
177
  shape = u.ele_shape(ele)
 
178
  mass = t.shape_shape(shape, shape)
 
179
  int_u = int_u + sum(numpy.dot(mass, u.ele_val(ele)))
 
180
  int_u_prev = int_u_prev + sum(numpy.dot(mass, u_prev.ele_val(ele)))
 
181
 
 
182
J = dt * (int_u + int_u_prev) * 0.5
 
183
#if not hasattr(J, "nominal_value"): 
 
184
#  print "J(%d): %s" % (n, J)
 
185
#  print "int(u[%d]): %s" % (n, int_u)
 
186
#  print "int(u[%d]): %s" % (n-1, int_u_prev)</string_value>
 
187
        </algorithm>
 
188
        <reduction>
 
189
          <sum/>
 
190
        </reduction>
 
191
      </functional_value>
 
192
      <functional_dependencies>
 
193
        <algorithm name="functional_dependencies">
 
194
          <string_value lines="20" type="python">def dependencies(times, timestep):
 
195
  return {"Fluid::Coordinate": [0],
 
196
          "Fluid::Velocity": [timestep-1, timestep]}</string_value>
 
197
        </algorithm>
 
198
      </functional_dependencies>
 
199
    </functional>
 
200
    <functional name="time_integral_hc">
 
201
      <functional_derivative>
 
202
        <algorithm name="functional_derivative">
 
203
          <string_value lines="20" type="python">import numpy
 
204
 
 
205
if n == 0 or n == len(times) - 1:
 
206
  multiple = 1
 
207
else:
 
208
  multiple = 2
 
209
  
 
210
dt = times[1] - times[0]
 
211
  
 
212
coord = states[0]["Fluid"].vector_fields["Coordinate"]
 
213
derivative.val[:] = 0.0
 
214
 
 
215
if derivative.name == "Fluid::Velocity":
 
216
  for ele in range(coord.element_count):
 
217
    t = Transform(ele, coord)
 
218
    shape = derivative.ele_shape(ele)
 
219
    derivative.addto(derivative.ele_nodes(ele), numpy.dot(shape.n, t.detwei))
 
220
    
 
221
  derivative.val[:] = (dt/2.0) * multiple * derivative.val</string_value>
 
222
        </algorithm>
 
223
      </functional_derivative>
 
224
      <functional_dependencies>
 
225
        <algorithm name="functional_dependencies">
 
226
          <string_value lines="20" type="python">def dependencies(times, timestep):
 
227
  return {"Fluid::Coordinate": [0],
 
228
          "Fluid::Velocity": [timestep-1, timestep]}</string_value>
 
229
        </algorithm>
 
230
      </functional_dependencies>
 
231
    </functional>
 
232
  </adjoint>
 
233
</burgers_equation>
 
 
b'\\ No newline at end of file'