flow3_input.txt

FLOW采用有限单元法fortran90编写的求解不可压缩流体的稳态流速和压力场的程序

          the bump parameter.

          Control the flow profile, and the cost of the bump.

          Discussion:

          This run did much better compared to the previous one,
          at least in the sense that it came closer to the target
          solution.  

          In particular, the shape of the bump was much more
          satisfactory.  The second and fourth parameters have
          much less influence on the flow, and typically get
          stuck in values that are far from the desired ones.
          For this run, the second parameter is positive, and
          both it and the fourth parameter are much closer to the
          correct values.

          The final parameter values were:

            0.500, 0.260, 0.478, 0.369


INPUT.03  Mesh:          21 by 7
          Weights:     * (1, 0, 0.001), 
                       * (1, 0, 0.00001)
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          Type:          0, optimization

          Make two runs, using smaller weights on the bump for
          the second run.

          Discussion:

          Although run #2 was so much better than run #1, the
          functional that we really want to minimize was still
          fairly large, having a value of 0.763E-3.  

          In order to improve this, we needed to restart the
          run with lower weights on the third (bump) cost.

          Here's the results:

          Parameter values after first part of run:

            0.500, 0.260, 0.478, 0.369

          Discrepancy cost:  

            0.763E-3

          Parameter values after second part of run:

            0.500, 0.340, 0.503, 0.370

          Discrepancy cost:

            0.801E-5


INPUT.04  Mesh:          21 by 7
          Weights:     * (1, 0, 0.001),
                       * (1, 0, 0.00001),
                       * (1, 0, 0)
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          Type:          0, optimization

          Starting from 0, solve (to convergence) the
          minimization problem for three runs,
          in each case, using the previous solution as the
          starting point for the next minimization.

          Discussion:

          If this method works, then we have shown that we can use
          the control costs as a way of smoothing out the main 
          cost functional when we are far from the solution, but
          then drop them down to zero as we approach, so that
          our final solution is a true minimum of the main cost
          functional.  

          The results (sketched below) show that this approach
          allowed us to avoid the local minimum, and to converge
          in to the correct answer.

          Parameter values after first part of run:

            0.500, 0.260, 0.477, 0.369

          Discrepancy cost:  

            0.763E-3

          Number of steps:

            38

          Parameter values after second part of run:

            0.500, 0.340, 0.503, 0.370

          Discrepancy cost:

            0.801E-5

          Number of steps:

            31

          Parameter values after third part of run:

            0.500, 0.375, 0.500, 0.375

          Discrepancy cost:

            0.296E-11

          Number of steps:

            26

INPUT.05  Mesh:          21 by 7
          Weights:     * (1, 0, 0.001),
                       * (1, 0, 0.00001),
                       * (1, 0, 0)
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          MAXOPT:      * 20
          Type:          0, optimization

          Starting from 0, solve (up to 20 steps) the 
          minimization problem for three runs,
          in each case, using the previous solution as the
          starting point for the next minimization.

          Discussion:

          In INPUT.04, we solved each minimization problem to
          convergence.  This may have been wasteful after a
          certain point.  We'd like to demonstrate that such
          accuracy is not necessary.
 
          The results (sketched below) show that it is not 
          necessary to converge to a minimum for one run
          before starting the next one.

          Parameter values after first part of run:

            0.502, 0.417, 0.510, 0.307

          Discrepancy functional:

            0.607E-4

          Number of steps:

            20 

          Parameter values after second part of run:

            0.500, 0.392, 0.499, 0.377

          Discrepancy functional:

            0.835E-5

          Number of steps:

            20

          Parameter values after third part of run:

            0.500, 0.375, 0.500, 0.375

          Discrepancy functional:

            0.716E-11

          Number of steps:

            27


INPUT.06  Mesh:          21 by 7
          Weights:     * (1, 0, 0.001),
                       * (1, 0, 0.00001),
                       * (1, 0, 0)
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          MAXOPT:      * 10
          Type:          0, optimization

          Starting from 0, solve (up to 10 steps) the 
          minimization problem for three runs,
          in each case, using the previous solution as the
          starting point for the next minimization.

          Discussion:

          Now we'd like to test the limits of the economies
          introduced in INPUT.05.  This time, we only take 10
          steps per minimization, keeping everything else the same.
 
          The results show that for this case, we didn't take
          enough steps in order to avoid the local minimum.

          Parameter values after first part of run:

            0.523, 0.001, 0.455, -0.075

          Discrepancy functional:

            0.168E-2

          Number of steps:

            10 

          Parameter values after second part of run:

            0.513, 0.007, 0.498, -0.087

          Discrepancy functional:

            0.273E-4

          Number of steps:

            10

          Parameter values after third part of run:

            0.508, -0.022, 0.526, 0.061

          Discrepancy functional:

            0.880E-5

          Number of steps:

            41

INPUT.07  Mesh:          21 by 7
          Weights:       (1, 0, 0)
          Reynolds:    * 10.0
          Parameters:    1 inflow, 3 bump.
          Type:          0, optimization

          Single run, no restarts.

          Discussion:

          This is the first run with a Reynolds number that is 
          not 1.  Janet warned me that the Reynolds number might
          be missing from some places, which would show up when
          a value different from 1 was used.  

          Also, the NSTOKE code may not converge for high
          Reynolds number.  

          However, no convergence problems were noted for this
          data.

          On the other hand, the parameters "converged" again to
          a "local" or "undesirable" minimum, although this time
          at least the "small" variables #2 and #4 were both
          positive.

          Parameter values after run:

            0.506, 0.013, 0.530, 0.058

          Discrepancy functional:

            0.510E-5

          Number of steps:

            43


INPUT.08  Mesh:          21 by 7
          Weights:       (1, 0, 0)
          Reynolds:    * 25.0
          Parameters:    1 inflow, 3 bump.
          Type:          0, optimization
          Discussion:

          Code took more optimization steps, and significantly more
          Newton steps, but no convergence problems showed up.

          Parameter values after run:

            0.501, 0.011, 0.525, 0.152

          Discrepancy functional:

            0.124E-5

          Number of steps:

            49
 
 
INPUT.09  Mesh:          21 by 7
          Weights:       (1, 0, 0)
          Reynolds:    * 50.0
          Parameters:    1 inflow, 3 bump.
          Type:          0, optimization

          Discussion:

          NSTOKE failed to converge!
          This occurred on the first computation of the flow, with
          parameters (1, 0, 0, 0).  NSTOKE took 8 steps without
          convergence, the difference in the last two steps being
          953.  The situation rapidly deteriorated.
          Looking at the final solution showed it to be real 
          garbage.
          The horizontal flows at the profile line, for instance, 
          were almost all NEGATIVE.  

          So my first impression is that, for a Reynolds number of 
          50, we're going to have problems with NSTOKE convergence 
          unless we're more careful about getting a good starting 
          point, or perhaps, damping the iteration.
 

INPUT.10  Mesh:        * 41 by 13
          Weights:       (1, 0, 0)
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          Type:          0, optimization
 
          Single run, no restart.
 
          Discussion:

          This run was made simply to examine the effects of mesh
          refinement on the calculation.

          The main point to note is that this finer calculation 
          managed to avoid the local minimum that snagged INPUT.01, 
          and reached the target value instead.

          On the other hand, it took 1.5 hours!
 
INPUT.11  Mesh:          21 by 7
          Weights:       (1, 0, 0)
          Reynolds:      1.0
          Parameters:  * 3 inflow, 1 bump.
          Type:          0, optimization

          The code was just changed to allow the parameters to be
          read in from the data file.  The first run of this
          data set was simply to test that option.

          This run will also be used to compare two ways of 
          computing the cost of inflow control.

          Discussion:

          Depressingly, this run shows the same kind of "wiggle"
          problems that the usual "bump" runs show.

          The optimizer seems stuck at the following "solution":

          Parameters:

            0.446, 0.450, 0.329, 0.498

          whereas the correct solution would be:

            0.375, 0.500, 0.375, 0.500

          This may reflect the poor nature of the flow discrepancy
          cost functional, at least at low Reynolds number, or
          the insensitivity of the flow to wiggles in the splines.


INPUT.12  Mesh:          21 by 7
          Weights:       (1, 0.001, 0)
                         (1, 0.00001, 0)
          Reynolds:      1.0
          Parameters:  * 3 inflow, 1 bump.
          Type:          0, optimization

          Discussion:

          Since the previous run didn't do what I wanted, I tried
          the same trick.

          Alas, the solution still has wiggles, and what's worse,
          the raw cost of control with the wiggly inflow is less
          than for the smooth inflow.  

          This really means I have to write the new cost function!

          Results of first run:

            0.423, 0.306, 0.423, 0.499

          Results of second run:

            0.421, 0.334, 0.413, 0.499,


INPUT.13  Mesh:          21 by 7
          Weights:       (1, 0.001, 0)
                         (1, 0.00001, 0)
          Reynolds:      1.0
          Parameters:  * 3 inflow, 1 bump.
          Type:          0, optimization

          I added an input parameter, ICOST, and set it so that if
          ICOST is 1, then the inflow cost is based on the integral
          of the square of the slope of the inflow, rather than
          on the square of the value.

          The results were dramatic.

          Results of first run:

            0.375, 0.500, 0.375, 0.501

          Results of second run:

            0.375, 0.500, 0.375, 0.500


INPUT.14  Mesh:          21 by 7, 
          Weights:       (1, 0, 0), 
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          Type:          0, optimization

          I added cost function #2, which measures the discrepancy
          in U, V and P along the profile line.  However, initial
          results showed slower convergence.  Perhaps this is
          because the pressures are so much larger.


INPUT.15  Mesh:          21 by 7, 
          Weights:       (1, 0, 0), 
          Reynolds:      1.0
          Parameters:  * 5 inflow, 0 bump.
          Type:          0, optimization

          Single run, ONE step!
 
          The only purpose of this run is to demonstrate how flow 
          in the channel tends to parabolic form regardless of 
          inflow conditions.
 

INPUT.16  Mesh:          21 by 7, 
          Weights:       (1, 0, 0), 
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          Type:        * 1, 1D march.

          First test of 1D marching capability, requiring that the
          march begin and end on specified points.


INPUT.17  Mesh:          21 by 7, 
          Weights:       (1, 0, 0), 
          Reynolds:      1.0
          Parameters:  * 1 bump.
          Type:          0, optimization

          I simply wanted to plot the sensitivity of the flow with
          respect to the single bump parameter.
 

INPUT.18  Mesh:          21 by 7, 
          Weights:       (1, 0, 0), 
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          Type:        * 1, 1D march.

          Second test of 1D marching capability, allowing march
          to begin before, and end after, two specified points.


INPUT.19  Mesh:          21 by 7, 
          Weights:       (1, 0, 0), 
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          Type:        * 2, 2D march.

          This was the first test of the 2D marching ability.


INPUT.20  Mesh:          21 by 7, 
          Weights:       (1, 0, 0), 
          Reynolds:      1.0
          Parameters:    1 inflow, 3 bump.
          Type:        * 2, 2D march.

This is the 2D march I made on the NCSA Cray, to get
data for the Scientific Visualization class.


#  INPUT.21  
#
#  Mesh:       21 by 7
#  Weights:    (1, 0, 0)
#  Reynolds:   1.0
#  Parameters: 1 inflow, 3 bump
#  Type:       2, 2D march.
#
#  2D march from just before local min through global min and 
#  beyond.
#
This is a repeat of run 20, but with cost function 2.


#  INPUT.22  
#
#  Mesh:       21 by 7
#  Weights:    (1, 0, 0)
#  Reynolds:   1.0
#  Parameters: 1 inflow, 3 bump
#  Type:       1, 1D march.
#
#  Start at (0,0,0,0) and increase each parameter in turn until
#  we reach the target value.
#
#  This is the input file I used to generate the movie I made
#  for the scientific visualization presentation.


#  INPUT.23
#
#  Mesh:       21 by 7
#  Weights:    (1, 0, 0, 0, 0)
#  Reynolds:   1.0
#  Parameters: 1 inflow, 0 bump
#  Type:       3, sensitivity
#
#  I am testing the sensitivity formulation, and need a simple
#  problem.
#
#  INPUT.24
#
#  Mesh:       21 by 7
#  Weights:    (1, 0, 0, 0, 0)
#  Reynolds:   1.0
#  Parameters: 3 inflow, 0 bump
#  Type:       3, sensitivity
#
This run was disappointing, in the sense that it got "hung up"
on what was probably a local minimum.  The functional value
was very small (about 1.0E-8) but the shape of the inflow
was very different from the desired 0.375, 0.500, 0.375 shape:

  0.42955      0.28060      0.43017

and was not changing.  This was probably due, in part, to the
insensitivity of the flow to anything in the inflow except its
bulk, and to the ultimate unsuitability (?) of the spline basis.
Naw, splines must be OK.



#  INPUT.25
#
#  Mesh:       21 by 7