January 4, 1999
---------------

Start preparing the selection of control samples for vertexing and dE/dx:

- gammagamma -> 4prongs
- D*/D

Good starting points (package/class):

EventTagTools/TagClassifyGammaGamma
EventTagTools/TagMakeDDstar

Some useful tricks learned recently:

a) to look at the code of a certain package in release 6.10.13:
setenv BFCURRENT 6.10.13
cd $BFDIST/releases/$BFCURRENT/package
...

b) to enable/disable modules or communicate parameter values:
use .tcl files; also, at run time give the corresponding commands,
even after starting the processing:
(> ev begin -nev ...)
> module enable SampleAnalysis
or:
> module disable SampleAnalysis
and, for instance:
> module talk SampleAnalysis
> verbose set t
> exit
> ev cont -nev ...

Some more details on Framework parameters and modules:

a) Class AbsParmIfdStrKey (doc from the class header):

//      Command handler for the "parm" command for
//      the module.  Provides a "filename" value. Valid commands are
//
//      parm set <x>                            set variable to x
//      parm list                               print parms
//
// AbsParmIfdStrKey is the standard way to put a secondary key parameter in a 
// module.  Recall that a secondary key is needed whenever two data
// items of the same type are stored in the event.  For example, there
// are several HepAList<TrkRecoTrk> lists in the event:  a default list,
// a Dch list, and an Svt list.  Secondary keys distinguish them.
//
// An AbsParmIfdStrKey is a parameter that allows a string provied by
// a user in a Tcl script to be converted into a key for usage in accessing
// the event.  Continuing with the example above, a track processing
// module might have an AbsParmIfdStrKey that has a default value
// of "DefaultTrack," but which the user may override in Tcl to change
// which list of tracks is used by the module.  If we called the parm
//    AbsParmIfdStrKey  key;
// we would fetch the data from the event with
//    HepAList<TrkRecoTrk> *tl = 
//       Ifd< IfdHepAList<TrkRecoTrk> >::get( ev, key.value() );
//
// An example is given in FrameExample/ParmExample.cc.

b) class AbsParmBool:

//      Command handler for the "parm" command for
//      the module.  Provides a "bool" value. Valid commands are
//
//      parm set <x>                            set variable to x
//      parm list                               print parms
//
//
// AbsParmBool provides a 'bool' that can be set and examined via
// some interface (the Framework command line, etc. No MicroFrame 
// support yet, and
// none envisioned for a while)  A module should create one of these
// for each parameter.  See FrameExample/ParmExample for a sample.
//
// Eventually, the AbsEnv class should provide a factory for
// these so they can be subtyped as needed to various database
// classes, etc.

More or less I get it, but I cannot completely understand the typical use
of an AbsParmIfdStrKey (= ? Abstract ? Parameter ? Ifd ? Str ? Key)
parameter:

a) in the module class header: declared as private data member

AbsParmIfdStrKey _btaTrackList;

b) in the constructor: included in the "initialization list"

, _btaTrackList("trackCandidates",this,"ChargedTracks"), 

c) in the constructor: "appended"??? to ??? 

  commands()->append(& _btaTrackList);

d) in the event() member function: ...?

    HepAList< BtaCandidate>* trackList;
    getTmpAList(anEvent, trackList, _btaTrackList.value());

what is obtained finally is clear: trackList is a pointer object to 
the list (type HepAList) of charged tracks (type BtaCandidate)
of the event; but how...?  
Let's leave this problem aside and proceed in practice with
the new class (module) in /babar0/users/lanceri/6.10.13/BetaUser

SelGammaGamma4Prongs.hh, cc


January 5th, 1999
-----------------