哪种设计模式适合这种情况？

Question

I have 2D hydraulic data, which are multigigabyte text files containing depth and velocity information for each point in a grid, broken up into time steps. Each timestep contains a depth/velocity value for every point in the grid. So you could follow one point through each timestep and see how its depth/velocity changes. I want to read in this data one timestep at a time, calculating various things - the maximum depth a grid cell achieves, max velocity, the number of the first timestep where water is more than 2 feet deep, etc. The results of each of these calculations will be a grid - max depth at each point, etc.

So far, this sounds like the Decorator pattern. However, I'm not sure how to get the results out of the various calculations - each calculation produces a different grid. I would have to keep references to each decorator after I create it in order to extract the results from it, or else add a getResults() method that returns a map of different results, etc, neither of which sound ideal.

Another option is the Strategy pattern. Each calculation is a different algorithm that operates on a time step (current depth/velocity) and the results of previous rounds (max depth so far, max velocity so far, etc). However, these previous results are different for each computation - which means either the algorithm classes become stateful, or it becomes the caller's job to keep track of previous results and feed them in. I also dislike the Strategy pattern because the behavior of looping over the timesteps becomes the caller's responsibility - I'd like to just give the "calculator" an iterator over the timesteps (fetching them from the disk as needed) and have it produce the results it needs.

Additional constraints:

• Input is large and being read from disk, so iterating exactly once, by time step, is the only practical method
• Grids are large, so calculations should be done in place as much as possible

Answer 1

If i understand your problem right, you have a grid_points which have many timesteps & each timestep has depth & velocity. Now have GBs of data.

I would suggest to do one pass on the data & store the parsed data in a RDBMS. then run queries or stored procedures on this data. This way at least the application will not run out of memory

Answer 2

First, maybe I've not well understood the issue and miss the point in my answer, in which case I apologize for taking your time.

At first sight I would think of an approach that's more akin to the "strategy pattern", in combination with a data-oriented base, something like the following pseudo-code:

foreach timeStamp

  readGridData

  foreach activeCalculator in activeCalculators

    useCalculatorPointerListToAccessSpecificStoredDataNeededForNewCalculation

    performCalculationOnFreshGridData

    updateUpdatableData

    presentUpdatedResultsToUser

    storeGridResultsInDataPool(OfResultBaseClassType)

    discardNoLongerNeededStoredGridResults

  next calculator
next timeStep

Again, sorry if this is off the point.