From:	SMTP%"shawn_edwards@MENTORG.COM" 17-MAY-1997 15:22:48.66
To:	QZLI
CC:	
Subj:	questions

Date: Sat, 17 May 1997 16:22:47 -0400
From: Shawn Edwards <shawn_edwards@MENTORG.COM>
Subject: questions
To: MAY@dana02.fnal.gov, paterno@porthos.fnal.gov, adams@physics.rice.edu
Cc: wyatt@FNAL.GOV, qzli@FNAL.GOV
Message-id: <199705172022.QAA11030@shawne>
Content-transfer-encoding: 7BIT


Brent, Mark, Dave & Company,

    First the administrative news.  As I mentioned before, John would be
unavailable until this week.  John successfully defended a few days ago and now
he has a few more days of work to do before we can spend some serious time on
your issues.  I mentioned in my earlier note that we had a few observations and
questions, but I then decided to spent a little time reading through some of
Dave Adam's web pages and so here they are (finally):

    We are encouraged that both of your proposals for the event data model were
levelizable and seemingly well structured.  The designs have a lot more in
common that I realized when I first saw them.  Here are a few questions I would
like to clear up:

    1) In Dave's design, chunks have the ability to generate thier own data.
       Is this a requirement? Or is it a feature that some think would be a
       good idea? 

    2) Can multiple instances of a paritcular chunk type exist in a given
       event?  Can multiple "versions" of a particular chunk type exist in a
       given event?  That is, how does a particular reconstructor object or
       generator specify what data (chunks) it needs as input to it's
       algorithms?  For example, suppose that a reconstructor with type reconA
       depends on raw data for it's input and that a reconstructor with type
       reconB depends on the output from a reconA type.

            reconA "asks" for raw data chunks from event
            reconA processes data and puts an AChunk into the event
            reconB "asks" for ?

       Does the reconB object simply ask for the latest AChunk that was added
       to the event?  (The sanity of the system would depend on a properly
       written script control file along with good automatic "type and version"
       checking possible at start-up time).  Does the reconB object ask for an
       AChunk with particular parameters?  (This could allow for multiple pairs
       of reconA and reconB objects working seperately...I'm not sure how this
       would be useful).  Does the reconB oject ask for an AChunk with a
       particular version?  (This would allow for different versions of
       algorithms and chunks to coexist in the same event).

    3) I was under the assumption that the check for whether or not the
       executable was built with all the necessary code just be done at
       start-up time at the lastest. Is this correct?
                        
    4) Would it be possible to firm up the requirements of an error
       handling/reporting mechanism.  I have the document (from the talk on the
       second day of my visit - sorry I forgot the person's name) on some
       Level3 requirements.  The requirements seem to be at a system level and
       I would like a more software architecture/programming level requirement.
       A web page or postscript document would be nice.  We have some ideas but
       don't know if this would fit your needs.

    5) We are interested/concerned as to how you will be using the D0OM
       preprocessor.  In the D0OM User Guide it says that it borrowed from the
       ROOT system.  I checked out the ROOT web site and found this:
    
        However, we preferred the approach of a programmer selectively
        deciding which data members should be written to disk. Data members
        caching some state of an object that can easily be reconstructed in
        the Streamer method do not have to be transferred to disk. Another
        example is when variables can be compacted into short words or even
        single bits (booleans). To aid the programmer we provide a tool to
        generate automatically a default Streamer method.

       I know that your preproccessor is, or is based on, cint but it seems
       that it would be beneficial to have the power to decide what is and what
       is not written to disk within a class.  The need for automatically
       generating dictionary files should somehow be balanced with the need to
       selectively stream what the class designer wants to.  Perhaps the
       solution will decide how and when you use your smart references.  This
       topic is probably a whole large issue in and of itself but I was just
       curious...
       
    Again, I will be working with John over the next few weeks.  Answers to the
first four questions above would help get us going.  

    Thanks,

p.s. Dave Adams, I need a little time to absorb some of the information that
you posted on your web page, but I am not sure why a Key (base class) needs to
know about an Event.  It would seem breaking this cycle should be easy if you
don't impose some of the requirements on Key.  I am not sure the all the
requirements are "sound" anyway.  Sometimes it is useful to question the
resonbilities that are assigned to an object.

p.p.s I have not forgot about my promise of sending you Pdep (GUI front end to
Idep).  John just asked the developer for some enhancements and the developer
just finished them.  I will now have to package everything up and send it to
you. 

-- 
Shawn Edwards
Mentor Graphics, IC Group (Warren, NJ)
shawn_edwards@mentorg.com