[Gmat-developers] GMAT Functions CDR RFAs

[Steven H. <Ste...@na...>]

Darrel,

    The design for GMAT functions is nearly complete and quite a feat of 
engineering!! Below are the comments from the meeting.  I pasted in 
answers - and some more questions for you - to the design review 
questions.  I also pasted in our comments for additional text and 
descriptions.  I'll fax you the copy of the marked up doc this afternoon.

Steve

%----------------------------------------------------------------
%------------------Responses to Review Questions -------------
%----------------------------------------------------------------

Q:  Are there existing components that will require modification?
A:  Sandbox, Moderator, Interpreter, Assignment Command, MathParser, 
MathTree, MatlabFunction, Factories

Q:  What are the specific mods to existing features.. new methods, new 
data structures, updates to existing data or methods?
A:  Darrel, can you provide a list of new methods and data structures 
needed on existing objects, and a list any other changes for existing 
components.

Q: Are new system components requiring development clearly identified?
A:  Yes they are:  Global Object Store, Local Object Store, Function 
Object Store, Function Class, Function Manager, Create Command, Global 
Command and Function Runner

Q:  What are the strengths and weaknesses in the design?
A:   Object stores are great way to avoid scoping problems. Function 
Manager does a great job of handling inline calls vs. CallFunction 
commands.   The fact that FCS is handled identically to MCS is a great 
for consistency and simplicity.  There are no major weaknesses, except 
perhaps how to handle subscribers which we haven't resolved yet.

Q:  What are the PMs, programmers, and testers major concerns?
A:   It's hard to understand  how all the different processes are 
ordered during build time, and where function stuff fits in to existing 
build time process described in the overview chapter.      A big picture 
diagram showing the order of Function Initialization, Interpreting FCS, 
Initialization of FCS, Initialization of Function Manager, and Execution 
would be really useful.

Q:  Is the explanation of the design clear and reasonably complete?
A:  It's hard to understand  how all the different processes are ordered 
during build time, and where function stuff fits in to existing build 
time process described in the overview chapter.   A big picture diagram 
showing the order of Function Initialization, Interpreting FCS, 
Initialization of FCS, Initialization of Function Manager, and Execution 
would be really useful.   There is missing information for Create 
Command and Global Command.

Q:  Which elements of the design are most likely to change?
A:  Subscriber handling.  Ordering of process during build and run.

Q:  Is the complexity of the design required and appropriate? Why isn't 
a simpler design better? Could a simpler design also meet requirements?
A:  I think the design is too simple :-)  Just kidding, given a feature 
of this magnitude, I think the complexity is appropriate.

Q:  Are there any aspects of the design that could cause difficulty in 
future development efforts?
A:   None that are apparent now.

Q:  Are there any remaining unresolved issues? Is the process for 
resolving these issues clearly identified?

%----------------------------------------------------------------
%----------- Comments and Needed Modifications -------------
%----------------------------------------------------------------

1)  It would help to make it clear in the text that Function Runner is 
on Math Tree.
2)  We need a new section, after Function Execution, that discusses the 
end-to-end example from a high level perspective and shows the order 
that the processes occur during initialization.  This is the single most 
important update we identified in the review process, with everyone 
agreeing it is necessary.
3)  We need to update the GMAT function requirements to address 
differing numbers of inputs in Function Call vs Function Declaration 
(same for outputs).
4)  We need to specifically say in the GMAT Function Requirements that 
we will not support overloading functions
5)  We need to make it clear in the intro paragraphs that the philosophy 
is to have GMAT functions behave as much as possible like Matlab 
function behave in Matlab.
7)  We need class diagrams for Function Runner and CallFunction
8)  Need to resolve where stack should reside and update the diagrams
9)  Need to make it more clear in text how function outputs get their 
values.
10)  We need to decide if we should implement internal functions now.