The Maker

The Code

Specifying Content for Micro-DSTs

• DoV0()
• DoXi()
• DoKink()
• DoMc()

  StStrangeMuDstMaker strangeDst();
  strangeDst.DoV0();

Note that DoMc() turns on processing of the Monte Carlo data and association branches for each of the content types turned on by any of the first three Do*() member functions.

  StStrangeMuDstMaker strangeDst();
  strangeDst.DoV0();     // Selects V0 vertices for micro-DST
  strangeDst.DoXi();     // Selects Xi vertices for micro-DST
  strangeDst.DoMc();     // Selects MC info for both V0 and Xi for micro-DST
  strangeDst.SetWrite(); // Sets "write" mode (using default filenames)

Creating on File

Creating in Memory

Persistence in Memory

  StStrangeMuDstMaker strangeDst();
  strangeDst.DoV0();
  strangeDst.SetNoKeep();

If the user is interested in reading in several micro-DSTs, the use of the StFile class is employed. StFile can take as an argument in its constructor an array of file names, any of which may also include wild cards (as in "ev*Dst.root"). Passing SetRead() a pointer to the StFile class then teaches StStrangeMuDstMaker what files to read. Here is an example:

  char* files[3];
  files[0] = "/bigfiles/run471.evMuDst.root";
  files[1] = "/bigfiles/run475.evMuDst.root";
  files[2] = "/oldfiles/run*.evMuDst.root";
  StFiles* flist = new StFile(files);
  StStrangeMuDstMaker strangeDst();
  strangeDst.SetRead(flist);

Access to the micro-DST is then available inside the event loop. Member functions outlined in the section below on Tools from StStrangeMuDstMaker allow the user to find out how many V0's, Xi's, or Kink's, as well as their respective Monte Carlo counterparts, are in the given event and access individual instances of the micro-DST component classes. The user can then loop over all vertices from an event, and can call member functions from the micro-DST component classes. A good example is provided in:
$STAR/StRoot/macros/analysis/readStrangeMuDst.C,
with an event loop looking something like this:

  Int_t Nevents = 10;
  // Loop over events
  for( Int_t i=0; i < Nevents; i++ ) {
    if( chain.Make(i) ) break;
    // Loop over V0 vertices
    for( Int_t j=0; j < strangeDst.GetNV0(); j++ ) {
      StV0MuDst *v0m = strangeDst.GetV0(j);
      hist->Fill(v0m->massLambda());
    }
    if( i != Nevents) chain.Clear();
  }
  chain.Finish();

Additionally, the user need not examine every event in the micro-DST. If the user specifies an integer parameter in the Make() member function call for the chain, then the event associated with that integer is read from the micro-DST. For example, if the event loop runs from i = 5...9, and the chain is run with chain.Make(i), then the 6th through 10th events on the file will be read in (the first event on file is event zero). This allows the user to skip events or read in only a portion of the events on the micro-DST. If no parameter is given to Make(), the micro-DST file is read from the beginning.

Monte Carlo Data

  Int_t Nevents = 10;
  // Loop over events
  for( Int_t i=0; i < Nevents; i++ ) {
    if( chain.Make(i) ) break;
    // Loop over V0 vertices
    for( Int_t j=0; j < strangeDst.GetNV0Assoc(); j++ ) {
      StStrangeAssoc* v0a = strangeDst.GetV0Assoc(j);
      StV0MuDst* v0m = strangeDst.GetV0(v0a->indexRecoArray());
      StV0Mc* v0mc = strangeDst.GetV0Mc(v0a->indexMcArray());
      hist->Fill(v0m->ptV0() - v0mc->ptV0());
    }
    if( i != Nevents) chain.Clear();
  }
  chain.Finish();

Code can be written that works identically for reconstructed and Monte Carlo data using the Get*I() functions and interface classes:

  Bool_t MC = kTRUE; // kFALSE for reconstructed data
  Int_t Nevents = 10;
  // Loop over events
  for( Int_t i=0; i < Nevents; i++ ) {
    if( chain.Make(i) ) break;
    // Loop over V0 vertices
    for( Int_t j=0; j < strangeDst.GetNV0I(MC); j++ ) {
      StV0I *v0i = strangeDst.GetV0I(j,MC);
      hist->Fill(v0i->pseudoRapV0());
    }
    if( i != Nevents) chain.Clear();
  }
  chain.Finish();

  StStrangeMuDstMaker strangeNewDst("strangeNewMuDst");
  strangeNewDst.DoV0();
  strangeNewDst.SetWrite("newEvMuDst.root");

  StStrangeMuDstMaker strangeOldDst("strangeOldMuDst");
  strangeOldDst.SetRead("oldEvMuDst.root");

  strangeNewDst.SubDst(strangeOldDst);

If one is filtering the micro-DST, new or additional cuts are probably also being used. If this is the case, one should consider adding cuts information to the strangeness cuts list stored with the micro-DST. More information on how to do this is available for the cuts.

The selection process for what goes into the sub-micro-DST can be viewed under two paradigms. The first paradigm encompasses a user who wants to take only those vertices which satisfy some criteria, and the second paradigm is for those who want to keep events which satisfy a criteria. Both selection processes are done during the event loop, between the Make() and Clear() member function calls of the chain. The event for the old micro-DST is read in during Make(), selections are made, and the new sub-micro-DST is written during Clear(). Selections are made via the Select*() member functions:

Vertex Selection Paradigm:

In this model, only certain vertices from within an event are selected to go on the sub-micro-DST. The vertices are selected with the following six member functions:

• SelectV0(j)
• SelectXi(j)
• SelectKink(j)
• UnselectV0(j)
• UnselectXi(j)
• UnselectKink(j)

In these calls, j specifies the index of the vertex within that event to be selected. For example, one might like to select only those cascades with a transverse momentum above 500 Mev/c. This would be done in a loop as follows:

  // Loop over events
  for( Int_t i=0; i < Nevents; i++ ) {
    if( chain.Make(i) ) break;
    // Loop over Xi vertices
    for( Int_t j=0; j < strangeOldDst.GetNXi(); j++ ) {
      StXiMuDst *xim = strangeDst.GetXi(j);
      if (xim->ptXi() > 0.5) strangeNewDst.SelectXi(j);
    }
    if( i != Nevents) chain.Clear();
  }
  chain.Finish();

The user can also specify that all of a specific vertex type can be selected for a particular event by setting the input parameter j to be a negative number. Thus, SelectV0(-1) would select all V0 candidates in the event, but would select no other vertex types for copying.

Similarly, one can unselect a specific vertex that one has already selected using the Unselect*() member functions. This is particularly useful if there are only a few vertices one would not wish to select, in which case one would use Select*(-1) followed by a few specific uses of Unselect*(j). Again, a negative input unselects the entire event.

One note of caution: Select*(j) does not check to see if a vertex has already been selected, so selecting one twice results in two copies.

Event Selection Paradigm:

If one wishes to select events as a whole for a sub-micro-DST, this can be done with the SelectEvent() member function. This essentially copies the entire event from the old micro-DST to the new sub-micro-DST, but is only true to the extent that what micro-DST components are turned on for the new maker (via the Do*() member functions, see Specifying Content for Micro-DSTs). Here is an example where the user takes all events which have more than 10 Kinks:

  // Loop over events
  for( Int_t i=0; i < Nevents; i++ ) {
    if( chain.Make(i) ) break;
    if (strangeOldDst.GetNKink() > 10) strangeNewDst.SelectEvent();
    if( i != Nevents) chain.Clear();
  }
  chain.Finish();

This is really the equivalent of using the vertex selection paradigm with input parameter j = -1 for all active components.

It is important to understand that an event which has not been selected will still have its event branch data copied to the filtered micro-DST, even if none of the secondary vertex data is copied. UnselectEvent() will restore any event in which any selections have already been made to this same state of copying the event branch only. If you truly want to eliminate an event entirely from the filtered micro-DST, then use AbortEvent(). Here is an example:

    StStrangeEvMuDst* ev = strageOlDst.GetEvent();
    if (fabs(ev->primaryVertexZ())<100.) {
      strangeNewDst.SelectEvent();
    } else {
      strangeNewDst.AbortEvent();
    }

• Getting a particular event from file:
  chain.Make(i)
  - Use the input parameter i of Make() to specify the index of the event read in (event indices start at zero). This is useful only in the read mode (see Reading Micro-DSTs)

• Getting the number of vertices for an event:
  Int_t GetNV0()
  Int_t GetNXi()
  Int_t GetNKink()
  - Returns an integer with the number of that particular vertex type.
  - Append "Mc" or "Assoc" to the function name for Monte Carlo vertices or associations between MC and reconstructed data.

• Getting a pointer to a particular vertex:
  StV0MuDst* GetV0(j)
  StXiMuDst* GetXi(j)
  StKinkMuDst* GetKink(j)
  - Use the input parameter j to specify the index of the vertex from that event, with indices starting at zero for each event.
  - Append "Mc" or "Assoc" to the function name for Monte Carlo vertices or associations between MC and reconstructed data.

• Getting a pointer to the event information:
  StStrangeEvMuDst* GetEvent()
  StStrangeEvMuDst* GetMcEvent()

• Getting a pointer to the TTree used for the micro-DST:
  TTree* GetTree()

• Getting access to the cuts on the micro-DST:
  StStrangeCuts& Cuts()
  - See documentation for StrangeCuts

• Getting a pointer to the TClonesArray used for collecting instances of the component classes of the micro-DST:
  TClonesArray* GetEvClonesArray()
  TClonesArray* GetV0ClonesArray()
  TClonesArray* GetXiClonesArray()
  TClonesArray* GetKinkClonesArray()
  - From the TClonesArray, one can get a vertex with index j via the operator[], like (*(maker.GetV0ClonesArray()))[j], but this is more simply done with the Get*(j) member functions described above.

• Treating MC and reconstructed data the same (interfaces):
  Get*I(Bool_t MC)
  - Switch easily back and forth between Monte Carlo and reconstructed data via input boolean MC.
  - Return types are usable for Monte Carlo and reconstructed data (i.e. StV0I is usable for both StV0MuDst and StV0Mc data classes).

Buffer Sizes

• SetV0BufferSize(b)
• SetXiBufferSize(b)
• SetKinkBufferSize(b)

Adding Content

Let's say I want to add a branch which contains a little bit of information that describes an event. In my example, I've made a new class called "StA" with two values that describe the event. This is what its header file looks like:

#ifndef StA_hh
#define StA_hh
#include "TObject.h"
class StA : public TObject {
  public:
   StA() {}
   virtual ~StA() {}
   Int_t value1;
   Float_t value2;
   ClassDef(StA,1)
};
#endif

1. Load the library for the new class:

     gSystem->Load("myNewLibrary");
   

2. Assign a new branch (I called mine "ABranch") for the new MuDst after the chain.Init() call, but before the event loop:

      StA::Class()->IgnoreTObjectStreamer(); // Don't store extra stuff
      TTree* tree = strangeNewDst.GetTree();
      TClonesArray* AArray = new TClonesArray("StA",1);
      tree->Branch("ABranch",&AArray,64000,99);
      StA* Ainstance = new((*AArray)[0]) StA();
   

3. Fill the data in the new branch during the event loop. Here is a simple example where I count Lambda candidates and their mean pt:

        Int_t totalLams = 0;
        Float_t totalLamPt = 0.;
        for( Int_t j = 0; j < strangeOldDst.GetNV0(); j++ ) {
          StV0MuDst *v0m = strangeOldDst.GetV0(j);
          Float_t ml = v0m->massLambda();
          if ((ml > 1.11) && (ml < 1.12)) {
            totalLams++;
            totalLamPt += v0m->ptV0();
          }
        }
        Ainstance->value1 = totalLams;
        Ainstance->value2 = totalLamPt/totalLams;
   

   TTree* tree = strangeNewDst.GetTree();
   TClonesArray* AArray = new TClonesArray("StA",0);
   tree->SetBranchStatus("ABranch.*",1);
   tree->SetBranchAddress("ABranch",&AArray);

     StA* Ainstance = (StA*) (AArray->At(0));