StRoot: macros/analysis/strangeFormulas.C Source File

00001 //======================================================
00002 // owner:  Gene Van Buren, UCLA
00003 // what it does:  creates formulas for use with strangeness micro DST
00004 // usage: The parameter is either a pointer to a strangeness
00005 //          micro DST tree, a pointer to a TFile containing such
00006 //          a tree (tree name assumed to be either "StrangeMuDst"
00007 //          or "MuDst" (in the case of a common micro DST)), or
00008 //          the name of such a file or files (one can use wildcards
00009 //          to examine the data in multiple files). In the latter
00010 //          two cases, a pointer to the strangeness TTree is returned.
00011 //          See documentation for more information.
00012 //
00013 //          After initial execution of the macro, the user may utilize
00014 //          the global pointers TTree* strangeTree or TChain* strangeChain.
00015 //          Additonal files can be added to the chain by calling
00016 //          strangeFormulas(filename) again.
00017 //
00018 // examples:
00019 //        .x strangeFormulas.C("myfile.root");
00020 //          Opens a file named "myfile.root", loads the formulas needed,
00021 //          and returns a pointer to the TTree.
00022 //        .x strangeFormulas.C("/path/to/otherfiles*.root");
00023 //          Opens all the files matching the pattern using a TChain.
00024 //          The returned pointer is the TChain cast to a TTree pointer.
00025 //        .x strangeFormulas.C("listfile.lis");
00026 //          Opens all the files specified in the file listfile.lis,
00027 //          whose format may simply be one filename per line, or the
00028 //          output of a call to: get_file_list.pl -keys path,filename ...
00029 //          The returned pointer is the TChain cast to a TTree pointer.
00030 //        .x strangeFormulas.C;
00031 //          Opens a file named "evMuDst.root", loads the formulas needed,
00032 //          and returns a pointer to the TTree (this is the default file).
00033 //        .x strangeFormulas.C(myTreePtr);
00034 //          Returns the number of new formulas loaded into Root.
00035 //        .x strangeFormulas.C(myFilePtr);
00036 //          Returns a pointer to the tree named either "StrangeMuDst"
00037 //          or "MuDst" in the file pointed to by myFilePtr.
00038 //======================================================
00039 //
00040 // Should be careful to optimize formulas for number of calls to
00041 // other formulas. TTreeFormula/TFormula is not smart enough to save
00042 // values to repeat them, and calculates the full thing twice, but
00043 // has a limit of 100 values one can calculate (only 50 values for
00044 // Root 2.24/04 and earlier).
00045 //
00046 // For example, "a()+a()+a()" repeats everything necessary to find
00047 // "a()" three times. If "a()" requires 20 values to calculate, then
00048 // "a()+a()+a()" will fail for Root 2.24/04, needing 60 values. Much
00049 // better to write something like "3*a()".
00050 //
00051 
00052 
00053 // Public interface:
00054 //    TTree* strangeFormulas(const char* fname=0, const char* tname=0);
00055 //    TTree* strangeFormulas(TFile* fptr);
00056 //     Int_t strangeFormulas(TTree* tree);
00057 //      void findFormulas(const char* c0, const char* c1=0, const char* c2=0);
00058 // TFormula* findFormula(const char* c0);       // Requires exact match
00059 //      void findDefinition(const char* c0);    // Requires exact match
00060 
00061 
00062 // Internal members and functions:
00063 // void formulate(const char* name, const char* formula);
00064 TTree* strangeTree=0;
00065 TChain* strangeChain=0;
00066 TCollection* ListofFuncs=0;
00067 Int_t max_codes=0;
00068 static const char* defaultFile = "evMuDst.root";
00069 static const char* defaultTree = "StrangeMuDst";
00070 static const char* altTree = "MuDst";
00071 
00072 //-----------------------------------------------------
00073 
00074 void prep() {
00075   if (!(gROOT->GetClass("TTreePlayer"))) {
00076     gSystem->Load("libTreePlayer");
00077     gSystem->Load("libProof");
00078   }
00079   if (!ListofFuncs) ListofFuncs=gROOT->GetListOfFunctions();
00080 }
00081 
00082 //-----------------------------------------------------
00083 
00084 void findFormulas(const char* c0, const char* c1=0, const char* c2=0) {
00085   for (Int_t i=0; i<ListofFuncs->GetSize(); i++) {
00086     TString ostr = ListofFuncs->At(i)->GetName();
00087     if (ostr.Contains(c0,TString::kIgnoreCase)) {
00088       if ((!c1) || (ostr.Contains(c1,TString::kIgnoreCase))) {
00089         if ((!c2) || (ostr.Contains(c2,TString::kIgnoreCase))) {
00090           cout << ostr.Data() << endl;
00091         }
00092       }
00093     }
00094   }
00095 }
00096 
00097 //-----------------------------------------------------
00098 
00099 TFormula* findFormula(const char* c0) {
00100   return (TFormula*) ListofFuncs->FindObject(c0);
00101 }
00102 
00103 //-----------------------------------------------------
00104     
00105 void findDefinition(const char* c0) {
00106   TFormula* f1 = findFormula(c0);
00107   if (f1) {
00108     cout << "Name       : " << f1->GetName() << endl;
00109     if (f1->IsA() == TTreeFormula::Class())
00110       cout << "# of Codes : " << ((TTreeFormula*) f1)->GetNcodes() << endl;
00111     cout << "Definition : " << f1->GetTitle() << endl;
00112   }
00113 }
00114 
00115 //-----------------------------------------------------
00116 
00117 void formulate(const char* name, const char* formula) {
00118   TTreeFormula* f1 = (TTreeFormula*) findFormula(name);
00119   if (f1) {
00120     f1->SetTree(strangeTree);
00121   } else {
00122     f1 = new TTreeFormula(name,formula,strangeTree);
00123     ListofFuncs->Add(f1);
00124     if (f1->GetNcodes() > max_codes) {
00125       cout << "\nWARNING!!! The following formula uses " << f1->GetNcodes();
00126       cout << " values,\n too many for this version of ROOT: \n";
00127       cout << f1->GetName() << " = " << f1->GetTitle() << endl;
00128     }
00129   }
00130 }
00131 
00132 //-----------------------------------------------------
00133 
00134 TTree* strangeFormulas(const char* fname=0, const char* tname=0) {
00135   if (!fname) {
00136     fname = defaultFile;
00137   } else {
00138     
00139     // Check for list files...
00140     TString fnamestr = fname;
00141     if (!(fnamestr.EndsWith(".root"))) {
00142       ifstream inlist(fname);
00143       if (!inlist) {
00144         cout << "\nERROR!!! Cannot find list file: " << fname << endl;
00145         return strangeTree;
00146       }
00147       char iname[256];
00148       TString inamestr;
00149       inlist >> iname;
00150       while (! inlist.eof()) {
00151         inamestr = iname;
00152         inamestr.ReplaceAll("::","/");
00153         inamestr.ReplaceAll("//","/");
00154         strangeFormulas(inamestr.Data(),tname);
00155         if (!strangeTree) {
00156           cout << "\nERROR!!! Trouble with first file: "
00157                << inamestr.Data() << endl;
00158           return 0;
00159         }
00160         inlist >> iname;
00161       }
00162       return strangeTree;
00163     }
00164   }
00165 
00166   // If we already have a chain and are just adding files...
00167   if (strangeChain) {
00168     strangeChain->Add(fname);
00169     return strangeTree;
00170   }
00171 
00172   // Start chain with the first filename...
00173   prep();
00174   if (!tname) {
00175     tname = defaultTree;
00176   }
00177   printf("Looking for tree with name %s\n",tname);
00178   strangeChain = new TChain(tname);
00179   strangeChain->Add(fname);
00180   if (strangeChain->LoadTree(0)) {
00181     delete strangeChain;
00182     strangeChain = 0;
00183     // Try again with altTree
00184     if (!(strcmp(tname,defaultTree))) return strangeFormulas(fname,altTree);
00185     return 0;
00186   }
00187   strangeTree = (TTree*) strangeChain;
00188   strangeFormulas(strangeTree);
00189   return strangeTree;
00190 }
00191 
00192 //-----------------------------------------------------
00193 
00194 TTree* strangeFormulas(TFile* fptr) {
00195   prep();
00196   if (!fptr) return 0;
00197   strangeTree = (TTree*) fptr->Get(defaultTree);
00198   if (!strangeTree) strangeTree = (TTree*) fptr->Get(altTree);
00199   strangeFormulas(strangeTree);
00200   return strangeTree;
00201 }
00202 
00203 //-----------------------------------------------------
00204 
00205 Int_t strangeFormulas(TTree* tree) {
00206   prep();
00207   if (!tree) return 0;
00208   if (gROOT->GetVersionInt() < 22405) {
00209     max_codes = 50;
00210   } else {
00211     max_codes = 100;
00212   }
00213 
00214   // These branches seem to require classes. No thanks.
00215   if (tree->GetBranch("EmcCollection")) {
00216     tree->SetBranchStatus("EmcCollection.*",0);
00217   }
00218   if (tree->GetBranch("PmdCollection")) {
00219     tree->SetBranchStatus("PmdCollection.*",0);
00220   }
00221 
00222   strangeTree = tree;
00223   char name[256];
00224   char expr[2048];
00225   char track[32];
00226   char temp[256];
00227   char ftpc[256];
00228   TString tstr;
00229 
00230   TFormula *f0=0;
00231   Int_t initialFormulas = ListofFuncs->GetSize();
00232   
00233   // Mass formulas
00234   f0 = new TFormula("mLambda", "1.11563");
00235   f0 = new TFormula("mAntiLambda", "1.11563");
00236   f0 = new TFormula("mK0Short", "0.497671");
00237   f0 = new TFormula("mProton", "0.938272");
00238   f0 = new TFormula("mAntiProton", "0.938272");
00239   f0 = new TFormula("mPiPlus", "0.139568");
00240   f0 = new TFormula("mPiMinus", "0.139568");
00241   f0 = new TFormula("mKaonMinus", "0.493646");
00242   
00243 
00244   // Event
00245   printf("Loading event formulas...\n");
00246   formulate("Event.run()", "Event.mRun");
00247   formulate("Event.event()", "abs(Event.mEvent)");
00248   formulate("Event.globalTracks()", "Event.mGlobalTracks");
00249   formulate("Event.primaryTracks()", "Event.mPrimaryTracks");
00250   formulate("Event.primaryNegTracks()", "Event.mPrimaryNegTracks");
00251   formulate("Event.primaryVertexX()", "Event.mPrimaryVertexX");
00252   formulate("Event.primaryVertexY()", "Event.mPrimaryVertexY");
00253   formulate("Event.primaryVertexZ()", "Event.mPrimaryVertexZ");
00254   formulate("Event.magneticField()",  "Event.mMagneticField");
00255   formulate("Event.l0TriggerWord()", "Event.mL0TriggerWord");
00256   formulate("Event.unbiasedTrigger()", "(Event.mEvent>0)");
00257 
00258   
00259   // McEvent
00260   if (tree->GetBranch("McEvent")) {
00261     printf("Loading MC event formulas...\n");
00262 
00263     formulate("McEvent.run()", "McEvent.mRun");
00264     formulate("McEvent.event()", "McEvent.mEvent");
00265     formulate("McEvent.globalTracks()", "McEvent.mGlobalTracks");
00266     formulate("McEvent.primaryTracks()", "McEvent.mPrimaryTracks");
00267     formulate("McEvent.primaryNegTracks()", "McEvent.mPrimaryNegTracks");
00268     formulate("McEvent.primaryVertexX()", "McEvent.mPrimaryVertexX");
00269     formulate("McEvent.primaryVertexY()", "McEvent.mPrimaryVertexY");
00270     formulate("McEvent.primaryVertexZ()", "McEvent.mPrimaryVertexZ");
00271 
00272   }  // End of McEvent
00273 
00274 
00275   // V0
00276   if (tree->GetBranch("V0")) {
00277     printf("Loading V0 formulas...\n");
00278   
00279     // The following formula uses 6 values:
00280     formulate("V0.decayLengthV0()",
00281       "sqrt(sq(V0.mDecayVertexV0X-Event.mPrimaryVertexX[0])+sq(V0.mDecayVertexV0Y-Event.mPrimaryVertexY[0])+sq(V0.mDecayVertexV0Z-Event.mPrimaryVertexZ[0]))");
00282   
00283     // The following formulas use 1 value:
00284     formulate("V0.decayVertexV0X()", "V0.mDecayVertexV0X");
00285     formulate("V0.decayVertexV0Y()", "V0.mDecayVertexV0Y");
00286     formulate("V0.decayVertexV0Z()", "V0.mDecayVertexV0Z");
00287     formulate("V0.dcaV0Daughters()", "V0.mDcaV0Daughters");
00288     formulate("V0.dcaV0ToPrimVertex()", "V0.mDcaV0ToPrimVertex");
00289     formulate("V0.dcaPosToPrimVertex()", "V0.mDcaPosToPrimVertex");
00290     formulate("V0.dcaNegToPrimVertex()", "V0.mDcaNegToPrimVertex");
00291     formulate("V0.momPosX()", "V0.mMomPosX");
00292     formulate("V0.momPosY()", "V0.mMomPosY");
00293     formulate("V0.momPosZ()", "V0.mMomPosZ");
00294     formulate("V0.momNegX()", "V0.mMomNegX");
00295     formulate("V0.momNegY()", "V0.mMomNegY");
00296     formulate("V0.momNegZ()", "V0.mMomNegZ");
00297     
00298     formulate("V0.radt2V0()", "sq(V0.mDecayVertexV0X)+sq(V0.mDecayVertexV0Y)");
00299     formulate("V0.radtV0()", "sqrt(V0.radt2V0())");
00300     formulate("V0.radV0()", "sqrt(V0.radt2V0()+sq(V0.mDecayVertexV0Z))");
00301     formulate("V0.phiV0()",
00302       "atan2((V0.mDecayVertexV0Y-Event.mPrimaryVertexY[0]),(V0.mDecayVertexV0X-Event.mPrimaryVertexX[0]))");
00303     formulate("V0.phi90V0()",
00304       "atan2(-(V0.mDecayVertexV0X-Event.mPrimaryVertexX[0]),(V0.mDecayVertexV0Y-Event.mPrimaryVertexY[0]))");
00305 
00306     formulate("V0.Ptot2Pos()",
00307       "(sq(V0.mMomPosX)+sq(V0.mMomPosY)+sq(V0.mMomPosZ))");
00308     formulate("V0.Ptot2Neg()",
00309       "(sq(V0.mMomNegX)+sq(V0.mMomNegY)+sq(V0.mMomNegZ))");
00310     formulate("V0.momV0X()", "(V0.mMomPosX+V0.mMomNegX)");
00311     formulate("V0.momV0Y()", "(V0.mMomPosY+V0.mMomNegY)");
00312     formulate("V0.momV0Z()", "(V0.mMomPosZ+V0.mMomNegZ)");
00313     formulate("V0.Pt2V0()", "(sq(V0.momV0X())+sq(V0.momV0Y()))");
00314     formulate("V0.Ptot2V0()", "(V0.Pt2V0()+sq(V0.momV0Z()))");
00315 
00316     // The following momentum component formulas use 15 values:
00317     formulate("V0.MomPosAlongV0()",
00318       "(((V0.mMomPosX*V0.momV0X())+(V0.mMomPosY*V0.momV0Y())+(V0.mMomPosZ*V0.momV0Z()))/sqrt(V0.Ptot2V0()))");
00319     formulate("V0.MomNegAlongV0()",
00320       "(((V0.mMomNegX*V0.momV0X())+(V0.mMomNegY*V0.momV0Y())+(V0.mMomNegZ*V0.momV0Z()))/sqrt(V0.Ptot2V0()))");
00321 
00322     formulate("V0.alphaV0()",
00323     //  "((V0.MomPosAlongV0()-V0.MomNegAlongV0())/(V0.MomPosAlongV0()+V0.MomNegAlongV0()))");
00324     // The above is cumbersome, using 50 values. The following uses 30:
00325       "1.-(2./(1.+(V0.MomPosAlongV0()/V0.MomNegAlongV0())))");
00326     // The following formula uses 18 values:
00327     formulate("V0.ptArmV0()", "sqrt(V0.Ptot2Pos()-sq(V0.MomPosAlongV0()))");
00328 
00329     // The following energy formulas use 6 values:
00330     formulate("V0.eLambda()", "sqrt(V0.Ptot2V0()+sq(mLambda))");
00331     formulate("V0.eK0Short()", "sqrt(V0.Ptot2V0()+sq(mK0Short))");
00332     formulate("V0.ePosProton()", "sqrt(V0.Ptot2Pos()+sq(mProton))");
00333     formulate("V0.eNegAntiProton()", "sqrt(V0.Ptot2Neg()+sq(mAntiProton))");
00334     formulate("V0.ePosPion()", "sqrt(V0.Ptot2Pos()+sq(mPiPlus))");
00335     formulate("V0.eNegPion()", "sqrt(V0.Ptot2Neg()+sq(mPiMinus))");
00336 
00337     // The following mass formulas use 12 values:
00338     formulate("V0.massLambda()",
00339       "sqrt(sq(V0.ePosProton()+V0.eNegPion())-V0.Ptot2V0())");
00340     formulate("V0.massAntiLambda()",
00341       "sqrt(sq(V0.eNegAntiProton()+V0.ePosPion())-V0.Ptot2V0())");
00342     formulate("V0.massK0Short()",
00343       "sqrt(sq(V0.ePosPion()+V0.eNegPion())-V0.Ptot2V0())");
00344     
00345     // The following rapidity formulas use 8 values:
00346     formulate("V0.rapLambda()",
00347     //  "0.5*log((V0.eLambda()+V0.momV0Z())/(V0.eLambda()-V0.momV0Z()))");
00348     // Can optimize for TTreeFormula:
00349       "0.5*log(1.+(2./((V0.eLambda()/V0.momV0Z())-1.)))");
00350     formulate("V0.rapK0Short()",
00351     //  "0.5*log((V0.eK0Short()+V0.momV0Z())/(V0.eK0Short()-V0.momV0Z()))");
00352     // Can optimize for TTreeFormula:
00353       "0.5*log(1.+(2./((V0.eK0Short()/V0.momV0Z())-1.)))");
00354 
00355     // The following cTau formulas use 24 values:
00356     formulate("V0.cTauLambda()",
00357       "V0.massLambda()*V0.decayLengthV0()/sqrt(V0.Ptot2V0())");
00358     formulate("V0.cTauK0Short()",
00359       "V0.massK0Short()*V0.decayLengthV0()/sqrt(V0.Ptot2V0())");
00360     
00361     formulate("V0.ptPos()", "sqrt(sq(V0.mMomPosX)+sq(V0.mMomPosY))");
00362     formulate("V0.ptotPos()", "sqrt(V0.Ptot2Pos())");
00363     formulate("V0.ptNeg()", "sqrt(sq(V0.mMomNegX)+sq(V0.mMomNegY))");
00364     formulate("V0.ptotNeg()", "sqrt(V0.Ptot2Neg())");
00365     formulate("V0.ptV0()", "sqrt(V0.Pt2V0())");
00366     formulate("V0.ptotV0()", "sqrt(V0.Ptot2V0())");
00367     formulate("V0.thetaV0()", "acos(V0.momV0Z()/V0.ptotV0())");
00368     formulate("V0.pseudoRapV0()", "-log(tan(V0.thetaV0()/2.))");
00369     formulate("V0.psiV0()", "atan2(V0.momV0Y(),V0.momV0X())");
00370     formulate("V0.psi90V0()", "atan2(-V0.momV0X(),V0.momV0Y())");
00371 
00372     // Track topology maps, with function names like
00373     // "V0.topologyMapNeg.*()" and "V0.topologyMapPos.*()"
00374     if (tree->GetBranch("V0.mTopologyMapPos.mMap0")) {
00375     for (int k=0; k<2; k++) {
00376       if (k) sprintf(track,"Neg\0");
00377       else sprintf(track,"Pos\0");
00378 
00379 
00380       // bit(i), i=0,63, uses only 1 value.
00381       for (int l=0; l<2; l++) {
00382         for (int j=0; j<32; j++) {
00383           int m = l*32 + j;
00384           sprintf(name,"V0.topologyMap%s.bit(%d)\0",track,m);
00385           sprintf(expr,"(V0.mTopologyMap%s.mMap%d/(2^%d))&1\0",track,l,j);
00386           formulate(name,expr);
00387         }
00388 
00389         // data(i), i=0,1, uses only 1 value.
00390         sprintf(name,"V0.topologyMap%s.data(%d)",track,l);
00391         sprintf(expr,"V0.mTopologyMap%s.mMap%d",track,l);
00392         formulate(name,expr);
00393       }
00394 
00395       // ftpcFormat()
00396       sprintf(ftpc,"V0.topologyMap%s.ftpcFormat()",track);
00397       sprintf(expr,"V0.topologyMap%s.bit(63)",track);
00398       formulate(ftpc,expr);
00399 
00400       // primaryVertexUsed()
00401       sprintf(name,"V0.topologyMap%s.primaryVertexUsed()",track);
00402       sprintf(expr,"V0.topologyMap%s.bit(0)",track);
00403       formulate(name,expr);
00404 
00405       // turnAroundFlag()
00406       sprintf(name,"V0.topologyMap%s.turnAroundFlag()",track);
00407       sprintf(expr,"V0.topologyMap%s.bit(62)",track);
00408       formulate(name,expr);
00409 
00410       // hasHitInSvtLayer(i), i=1,6
00411       for (int j=1; j<7; j++) {
00412         sprintf(name,"V0.topologyMap%s.hasHitInSvtLayer(%d)",track,j);
00413         sprintf(temp,"V0.topologyMap%s.bit(%d)\0",track,j);
00414         sprintf(expr,"(!%s)&&(%s)\0",ftpc,temp);
00415         formulate(name,expr);
00416         
00417         tstr += temp;
00418         if (j<6) tstr += "+";
00419       }
00420 
00421       // numOfSvtHits(), uses 6 values
00422       sprintf(name,"V0.topologyMap%s.numOfSvtHits()\0",track);
00423       sprintf(expr,"(!%s)*(%s)\0",ftpc,tstr.Data());
00424       formulate(name,expr);
00425       tstr = "";
00426       
00427       // hasHitInSsd()
00428       sprintf(name,"V0.topologyMap%s.hasHitInSsd()",track);
00429       sprintf(expr,"V0.topologyMap%s.bit(7)",track);
00430       formulate(name,expr);
00431 
00432       sprintf(temp,"(!%s)*(\0",ftpc);
00433       tstr = temp;
00434 
00435       // hasHitInTpcRow(i), i=0,44
00436       for (int j=0; j<45; j++) {
00437         sprintf(name,"V0.topologyMap%s.hasHitInTpcRow(%d)",track,j);
00438         int m = j+8;
00439         sprintf(temp,"V0.topologyMap%s.bit(%d)\0",track,m);
00440         sprintf(expr,"(!%s)&&(%s)\0",ftpc,temp);
00441         formulate(name,expr);
00442         
00443         tstr += temp;
00444         if (j<44) tstr += "+";
00445       }
00446 
00447       // numOfTpcHits(), uses 45 values.
00448       sprintf(name,"V0.topologyMap%s.numOfTpcHits()\0",track);
00449       tstr += ")";
00450       formulate(name,tstr.Data());
00451       tstr = "";
00452 
00453       // hasHitInMwpc()
00454       sprintf(name,"V0.topologyMap%s.hasHitInMwpc()",track);
00455       sprintf(expr,"V0.topologyMap%s.bit(53)",track);
00456       formulate(name,expr);
00457 
00458       // hasHitInCtb()
00459       sprintf(name,"V0.topologyMap%s.hasHitInCtb()",track);
00460       sprintf(expr,"V0.topologyMap%s.bit(54)",track);
00461       formulate(name,expr);
00462 
00463       // hasHitInTofPatch()
00464       sprintf(name,"V0.topologyMap%s.hasHitInTofPatch()",track);
00465       sprintf(expr,"V0.topologyMap%s.bit(55)",track);
00466       formulate(name,expr);
00467 
00468       // hasHitInRich()
00469       sprintf(name,"V0.topologyMap%s.hasHitInRich()",track);
00470       sprintf(expr,"V0.topologyMap%s.bit(56)",track);
00471       formulate(name,expr);
00472 
00473       // hasHitInBarrelEmc()
00474       sprintf(name,"V0.topologyMap%s.hasHitInBarrelEmc()",track);
00475       sprintf(expr,"V0.topologyMap%s.bit(57)",track);
00476       formulate(name,expr);
00477 
00478       // hasHitInEndcapEmc()
00479       sprintf(name,"V0.topologyMap%s.hasHitInEndcapEmc()",track);
00480       sprintf(expr,"V0.topologyMap%s.bit(58)",track);
00481       formulate(name,expr);
00482     } } // End topology maps
00483 
00484     // The following formulas use 1 value:
00485     formulate("V0.chi2V0()", "V0.mChi2V0");
00486     formulate("V0.clV0()", "V0.mClV0");
00487     formulate("V0.chi2Pos()", "V0.mChi2Pos");
00488     formulate("V0.clPos()", "V0.mClPos");
00489     formulate("V0.dedxPos()", "V0.mDedxPos");
00490     formulate("V0.numDedxPos()", "V0.mNumDedxPos");
00491     formulate("V0.chi2Neg()", "V0.mChi2Neg");
00492     formulate("V0.clNeg()", "V0.mClNeg");
00493     formulate("V0.dedxNeg()", "V0.mDedxNeg");
00494     formulate("V0.numDedxNeg()", "V0.mNumDedxNeg");
00495 
00496   }  // End of V0
00497 
00498   // V0Mc
00499   if (tree->GetBranch("V0Mc")) {
00500     printf("Loading V0Mc formulas...\n");
00501 
00502     // The following formula uses 6 values:
00503     formulate("V0Mc.decayLengthV0()",
00504       "sqrt(sq(V0Mc.mPositionX-McEvent.mPrimaryVertexX[0])+sq(V0Mc.mPositionY-McEvent.mPrimaryVertexY[0])+sq(V0Mc.mPositionZ-McEvent.mPrimaryVertexZ[0]))");
00505 
00506     // The following formulas use 1 value:
00507     formulate("V0Mc.decayMode()", "V0Mc.mDecayMode");
00508     formulate("V0Mc.positiveCommonTpcHits()", "V0Mc.mPositiveCommonTpcHits");
00509     formulate("V0Mc.positiveSimTpcHits()", "V0Mc.mPositiveSimTpcHits");
00510     formulate("V0Mc.negativeCommonTpcHits()", "V0Mc.mNegativeCommonTpcHits");
00511     formulate("V0Mc.negativeSimTpcHits()", "V0Mc.mNegativeSimTpcHits");
00512     formulate("V0Mc.geantIdParent()", "V0Mc.mParentGeantId");
00513     formulate("V0Mc.geantIdPositive()", "V0Mc.mPositiveGeantId");
00514     formulate("V0Mc.geantIdNegative()", "V0Mc.mNegativeGeantId");
00515     formulate("V0Mc.parentMomentumX()", "V0Mc.mParentMomentumX");
00516     formulate("V0Mc.parentMomentumY()", "V0Mc.mParentMomentumY");
00517     formulate("V0Mc.parentMomentumZ()", "V0Mc.mParentMomentumZ");
00518     formulate("V0Mc.positiveMomentumX()", "V0Mc.mPositiveMomentumX");
00519     formulate("V0Mc.positiveMomentumY()", "V0Mc.mPositiveMomentumY");
00520     formulate("V0Mc.positiveMomentumZ()", "V0Mc.mPositiveMomentumZ");
00521     formulate("V0Mc.negativeMomentumX()", "V0Mc.mNegativeMomentumX");
00522     formulate("V0Mc.negativeMomentumY()", "V0Mc.mNegativeMomentumY");
00523     formulate("V0Mc.negativeMomentumZ()", "V0Mc.mNegativeMomentumZ");
00524     formulate("V0Mc.positionX()", "V0Mc.mPositionX");
00525     formulate("V0Mc.positionY()", "V0Mc.mPositionY");
00526     formulate("V0Mc.positionZ()", "V0Mc.mPositionZ");
00527 
00528   }  // End of V0Mc
00529   
00530 
00531   // Xi
00532   if (tree->GetBranch("Xi")) {
00533     printf("Loading Xi formulas...\n");
00534 
00535     f0 = new TFormula("mXiMinus", "1.32133");
00536     f0 = new TFormula("mOmegaMinus", "1.67243");
00537 
00538     // First, the Xi's get all the same functions that the V0's get...
00539     // The following formula uses 6 values:
00540     formulate("Xi.decayLengthV0()",
00541       "sqrt(sq(Xi.mDecayVertexV0X-Xi.mDecayVertexXiX)+sq(Xi.mDecayVertexV0Y-Xi.mDecayVertexXiY)+sq(Xi.mDecayVertexV0Z-Xi.mDecayVertexXiZ))");
00542 //      "sqrt(sq(Xi.mDecayVertexV0X-Event.mPrimaryVertexX[0])+sq(Xi.mDecayVertexV0Y-Event.mPrimaryVertexY[0])+sq(Xi.mDecayVertexV0Z-Event.mPrimaryVertexZ[0]))");
00543 
00544     // The following formulas use 1 value:
00545     formulate("Xi.decayVertexV0X()", "Xi.mDecayVertexV0X");
00546     formulate("Xi.decayVertexV0Y()", "Xi.mDecayVertexV0Y");
00547     formulate("Xi.decayVertexV0Z()", "Xi.mDecayVertexV0Z");
00548     formulate("Xi.dcaV0Daughters()", "Xi.mDcaV0Daughters");
00549     formulate("Xi.dcaV0ToPrimVertex()", "Xi.mDcaV0ToPrimVertex");
00550     formulate("Xi.dcaPosToPrimVertex()", "Xi.mDcaPosToPrimVertex");
00551     formulate("Xi.dcaNegToPrimVertex()", "Xi.mDcaNegToPrimVertex");
00552     formulate("Xi.momPosX()", "Xi.mMomPosX");
00553     formulate("Xi.momPosY()", "Xi.mMomPosY");
00554     formulate("Xi.momPosZ()", "Xi.mMomPosZ");
00555     formulate("Xi.momNegX()", "Xi.mMomNegX");
00556     formulate("Xi.momNegY()", "Xi.mMomNegY");
00557     formulate("Xi.momNegZ()", "Xi.mMomNegZ");
00558 
00559     formulate("Xi.radt2V0()", "sq(Xi.mDecayVertexV0X)+sq(Xi.mDecayVertexV0Y)");
00560     formulate("Xi.radtV0()", "sqrt(Xi.radt2V0())");
00561     formulate("Xi.radV0()", "sqrt(Xi.radt2V0()+sq(Xi.mDecayVertexV0Z))");
00562     formulate("Xi.phiV0()",
00563       "atan2((Xi.mDecayVertexV0Y-Xi.mDecayVertexXiY),(Xi.mDecayVertexV0X-Xi.mDecayVertexXiX))");
00564 //      "atan2((Xi.mDecayVertexV0Y-Event.mPrimaryVertexY[0]),(Xi.mDecayVertexV0X-Event.mPrimaryVertexX[0]))");
00565 
00566     formulate("Xi.Ptot2Pos()",
00567       "(sq(Xi.mMomPosX)+sq(Xi.mMomPosY)+sq(Xi.mMomPosZ))");
00568     formulate("Xi.Ptot2Neg()",
00569       "(sq(Xi.mMomNegX)+sq(Xi.mMomNegY)+sq(Xi.mMomNegZ))");
00570     formulate("Xi.momV0X()", "(Xi.mMomPosX+Xi.mMomNegX)");
00571     formulate("Xi.momV0Y()", "(Xi.mMomPosY+Xi.mMomNegY)");
00572     formulate("Xi.momV0Z()", "(Xi.mMomPosZ+Xi.mMomNegZ)");
00573     formulate("Xi.Pt2V0()", "(sq(Xi.momV0X())+sq(Xi.momV0Y()))");
00574     formulate("Xi.Ptot2V0()", "(Xi.Pt2V0()+sq(Xi.momV0Z()))");
00575 
00576     // The following momentum component formulas use 15 values:
00577     formulate("Xi.MomPosAlongV0()",
00578       "(((Xi.mMomPosX*Xi.momV0X())+(Xi.mMomPosY*Xi.momV0Y())+(Xi.mMomPosZ*Xi.momV0Z()))/sqrt(Xi.Ptot2V0()))");
00579     formulate("Xi.MomNegAlongV0()",
00580       "(((Xi.mMomNegX*Xi.momV0X())+(Xi.mMomNegY*Xi.momV0Y())+(Xi.mMomNegZ*Xi.momV0Z()))/sqrt(Xi.Ptot2V0()))");
00581 
00582     formulate("Xi.alphaV0()",
00583     //  "((Xi.MomPosAlongV0()-Xi.MomNegAlongV0())/(Xi.MomPosAlongV0()+Xi.MomNegAlongV0()))");
00584     // The above is cumbersome, using 50 values. The following uses 30:
00585       "1.-(2./(1.+(Xi.MomPosAlongV0()/Xi.MomNegAlongV0())))");
00586     // The following formula uses 18 values:
00587     formulate("Xi.ptArmV0()",
00588       "sqrt(Xi.Ptot2Pos()-sq(Xi.MomPosAlongV0()))");
00589 
00590     // The following energy formulas use 6 values:
00591     formulate("Xi.eLambda()", "sqrt(Xi.Ptot2V0()+sq(mLambda))");
00592     formulate("Xi.eK0Short()", "sqrt(Xi.Ptot2V0()+sq(mK0Short))");
00593     formulate("Xi.ePosProton()", "sqrt(Xi.Ptot2Pos()+sq(mProton))");
00594     formulate("Xi.eNegAntiProton()", "sqrt(Xi.Ptot2Neg()+sq(mAntiProton))");
00595     formulate("Xi.ePosPion()", "sqrt(Xi.Ptot2Pos()+sq(mPiPlus))");
00596     formulate("Xi.eNegPion()", "sqrt(Xi.Ptot2Neg()+sq(mPiMinus))");
00597 
00598     // The following mass formulas use 12 values:
00599     formulate("Xi.massLambda()",
00600       "sqrt(sq(Xi.ePosProton()+Xi.eNegPion())-Xi.Ptot2V0())");
00601     formulate("Xi.massAntiLambda()",
00602       "sqrt(sq(Xi.eNegAntiProton()+Xi.ePosPion())-Xi.Ptot2V0())");
00603     formulate("Xi.massK0Short()",
00604       "sqrt(sq(Xi.ePosPion()+Xi.eNegPion())-Xi.Ptot2V0())");
00605     
00606     // The following rapidity formulas use 8 values:
00607     formulate("Xi.rapLambda()",
00608     //  "0.5*log((Xi.eLambda()+Xi.momV0Z())/(Xi.eLambda()-Xi.momV0Z()))");
00609     // Can optimize for TTreeFormula:
00610       "0.5*log(1.+(2./((Xi.eLambda()/Xi.momV0Z())-1.)))");
00611     formulate("Xi.rapK0Short()",
00612     //  "0.5*log((Xi.eK0Short()+Xi.momV0Z())/(Xi.eK0Short()-Xi.momV0Z()))");
00613     // Can optimize for TTreeFormula:
00614       "0.5*log(1.+(2./((Xi.eK0Short()/Xi.momV0Z())-1.)))");
00615 
00616     // The following cTau formulas use 24 values:
00617     formulate("Xi.cTauLambda()",
00618       "Xi.massLambda()*Xi.decayLengthV0()/sqrt(Xi.Ptot2V0())");
00619     formulate("Xi.cTauK0Short()",
00620       "Xi.massK0Short()*Xi.decayLengthV0()/sqrt(Xi.Ptot2V0())");
00621     
00622     formulate("Xi.ptPos()", "sqrt(sq(Xi.mMomPosX)+sq(Xi.mMomPosY))");
00623     formulate("Xi.ptotPos()", "sqrt(Xi.Ptot2Pos())");
00624     formulate("Xi.ptNeg()", "sqrt(sq(Xi.mMomNegX)+sq(Xi.mMomNegY))");
00625     formulate("Xi.ptotNeg()", "sqrt(Xi.Ptot2Neg())");
00626     formulate("Xi.ptV0()", "sqrt(Xi.Pt2V0())");
00627     formulate("Xi.ptotV0()", "sqrt(Xi.Ptot2V0())");
00628     formulate("Xi.thetaV0()", "acos(Xi.momV0Z()/Xi.ptotV0())");
00629     formulate("Xi.pseudoRapV0()", "-log(tan(Xi.thetaV0()/2.))");
00630     formulate("Xi.psiV0()", "atan2(Xi.momV0Y(),Xi.momV0X())");
00631 
00632     // The following formulas use 1 value:
00633     formulate("Xi.chi2V0()", "Xi.mChi2V0");
00634     formulate("Xi.clV0()", "Xi.mClV0");
00635     formulate("Xi.chi2Pos()", "Xi.mChi2Pos");
00636     formulate("Xi.dedxPos()", "Xi.mDedxPos");
00637     formulate("Xi.numDedxPos()", "Xi.mNumDedxPos");
00638     formulate("Xi.clPos()", "Xi.mClPos");
00639     formulate("Xi.chi2Neg()", "Xi.mChi2Neg");
00640     formulate("Xi.clNeg()", "Xi.mClNeg");
00641     formulate("Xi.dedxNeg()", "Xi.mDedxNeg");
00642     formulate("Xi.numDedxNeg()", "Xi.mNumDedxNeg");
00643 
00644 
00645     // Now, finally get to the unique Xi formulas:
00646     // The following formula uses 6 values:
00647     // A straight line approximation to the path...
00648     formulate("Xi.decayLengthXi()",
00649       "sqrt(sq(Xi.mDecayVertexXiX-Event.mPrimaryVertexX[0])+sq(Xi.mDecayVertexXiY-Event.mPrimaryVertexY[0])+sq(Xi.mDecayVertexXiZ-Event.mPrimaryVertexZ[0]))");
00650 
00651     // The following formulas use 1 value:
00652     formulate("Xi.charge()", "Xi.mCharge");
00653     formulate("Xi.decayVertexXiX()", "Xi.mDecayVertexXiX");
00654     formulate("Xi.decayVertexXiY()", "Xi.mDecayVertexXiY");
00655     formulate("Xi.decayVertexXiZ()", "Xi.mDecayVertexXiZ");
00656     formulate("Xi.dcaXiDaughters()", "Xi.mDcaXiDaughters");
00657     formulate("Xi.dcaXiToPrimVertex()", "Xi.mDcaXiToPrimVertex");
00658     formulate("Xi.dcaBachelorToPrimVertex()", "Xi.mDcaBachelorToPrimVertex");
00659     formulate("Xi.momBachelorX()", "Xi.mMomBachelorX");
00660     formulate("Xi.momBachelorY()", "Xi.mMomBachelorY");
00661     formulate("Xi.momBachelorZ()", "Xi.mMomBachelorZ");
00662     formulate("Xi.momXiX()", "Xi.mMomBachelorX+Xi.momV0X()");
00663     formulate("Xi.momXiY()", "Xi.mMomBachelorY+Xi.momV0Y()");
00664     formulate("Xi.momXiZ()", "Xi.mMomBachelorZ+Xi.momV0Z()");
00665     formulate("Xi.keyBachelor()", "Xi.mKeyBachelor");
00666 
00667     formulate("Xi.radt2Xi()", "sq(Xi.mDecayVertexXiX)+sq(Xi.mDecayVertexXiY)");
00668     formulate("Xi.radtXi()", "sqrt(Xi.radt2Xi())");
00669     formulate("Xi.radXi()", "sqrt(Xi.radt2Xi()+sq(Xi.mDecayVertexXiZ))");
00670     formulate("Xi.phiXi()",
00671       "atan2((Xi.mDecayVertexXiY-Event.mPrimaryVertexY[0]),(Xi.mDecayVertexXiX-Event.mPrimaryVertexX[0]))");
00672 
00673     formulate("Xi.Ptot2Bachelor()",
00674       "(sq(Xi.mMomBachelorX)+sq(Xi.mMomBachelorY)+sq(Xi.mMomBachelorZ))");
00675     formulate("Xi.Pt2Xi()", "(sq(Xi.momXiX())+sq(Xi.momXiY()))");
00676     formulate("Xi.Ptot2Xi()", "(Xi.Pt2Xi()+sq(Xi.momXiZ()))");
00677 
00678     // The following momentum component formulas use 21 and 24 values:
00679     formulate("Xi.MomBachelorAlongXi()",
00680        "(((Xi.mMomBachelorX*Xi.momXiX())+(Xi.mMomBachelorY*Xi.momXiY())+(Xi.mMomBachelorZ*Xi.momXiZ()))/sqrt(Xi.Ptot2Xi()))");
00681     formulate("Xi.MomV0AlongXi()",
00682        "(((Xi.momV0X()*Xi.momXiX())+(Xi.momV0Y()*Xi.momXiY())+(Xi.momV0Z()*Xi.momXiZ()))/sqrt(Xi.Ptot2Xi()))");
00683 
00684     formulate("Xi.alphaXi()",
00685     //  "(Xi.mCharge*(Xi.MomBachelorAlongXi()-Xi.MomV0AlongXi())/(Xi.MomBachelorAlongXi()+Xi.MomV0AlongXi()))");
00686     // The above is cumbersome, using 50 values. The following uses 30:
00687       "Xi.mCharge*(1.-(2./(1.+(Xi.MomBachelorAlongXi()/Xi.MomV0AlongXi()))))");
00688     // The following formula uses 30 values:
00689     formulate("Xi.ptArmXi()",
00690       "sqrt(Xi.Ptot2V0()-sq(Xi.MomV0AlongXi()))");
00691 
00692     // The following energy formulas use 9 values:
00693     formulate("Xi.eXi()", "sqrt(Xi.Ptot2Xi()+sq(mXiMinus))");
00694     formulate("Xi.eOmega()", "sqrt(Xi.Ptot2Xi()+sq(mOmegaMinus))");
00695     formulate("Xi.eBachelorPion()", "sqrt(Xi.Ptot2Bachelor()+sq(mPiMinus))");
00696     formulate("Xi.eBachelorKaon()", "sqrt(Xi.Ptot2Bachelor()+sq(mKaonMinus))");
00697 
00698     // The following mass formulas use 18 values:
00699     formulate("Xi.massXi()",
00700       "sqrt(sq(Xi.eLambda()+Xi.eBachelorPion())-Xi.Ptot2Xi())");
00701     formulate("Xi.massOmega()",
00702       "sqrt(sq(Xi.eLambda()+Xi.eBachelorKaon())-Xi.Ptot2Xi())");
00703     
00704     // The following rapidity formulas use 12 values:
00705     formulate("Xi.rapXi()",
00706     //  "0.5*log((Xi.eXi()+Xi.momXiZ())/(Xi.eXi()-Xi.momXiZ()))");
00707     // Can optimize for TTreeFormula:
00708       "0.5*log(1.+(2./((Xi.eXi()/Xi.momXiZ())-1.)))");
00709     formulate("Xi.rapOmega()",
00710     //  "0.5*log((Xi.eOmega()+Xi.momXiZ())/(Xi.eOmega()-Xi.momXiZ()))");
00711     // Can optimize for TTreeFormula:
00712       "0.5*log(1.+(2./((Xi.eOmega()/Xi.momXiZ())-1.)))");
00713 
00714     // The following cTau formulas use 33 values:
00715     formulate("Xi.cTauXi()",
00716       "Xi.massXi()*Xi.decayLengthXi()/sqrt(Xi.Ptot2Xi())");
00717     formulate("Xi.cTauOmega()",
00718       "Xi.massOmega()*Xi.decayLengthXi()/sqrt(Xi.Ptot2Xi())");
00719     
00720     formulate("Xi.ptBachelor()",
00721       "sqrt(sq(Xi.mMomBachelorX)+sq(Xi.mMomBachelorY))");
00722     formulate("Xi.ptotBachelor()", "sqrt(Xi.Ptot2Bachelor())");
00723     formulate("Xi.ptXi()", "sqrt(Xi.Pt2Xi())");
00724     formulate("Xi.ptotXi()", "sqrt(Xi.Ptot2Xi())");
00725     formulate("Xi.thetaXi()", "acos(Xi.momXiZ()/Xi.ptotXi())");
00726     formulate("Xi.pseudoRapXi()", "-log(tan(Xi.thetaXi()/2.))");
00727     formulate("Xi.psiXi()", "atan2(Xi.momXiY(),Xi.momXiX())");
00728 
00729     // Track topology maps, with function names like
00730     // "Xi.topologyMapNeg.*()", Xi.topologyMapPos.*(),
00731     // and "Xi.topologyMapBachelor.*()"
00732     if (tree->GetBranch("Xi.mTopologyMapBachelor.mMap0")) {
00733     for (int k=0; k<3; k++) {
00734       if (k==2) sprintf(track,"Bachelor\0");
00735       else if (k==1) sprintf(track,"Neg\0");
00736       else sprintf(track,"Pos\0");
00737 
00738 
00739       // bit(i), i=0,63, uses only 1 value.
00740       for (int l=0; l<2; l++) {
00741         for (int j=0; j<32; j++) {
00742           int m = l*32 + j;
00743           sprintf(name,"Xi.topologyMap%s.bit(%d)\0",track,m);
00744           sprintf(expr,"(Xi.mTopologyMap%s.mMap%d/(2^%d))&1\0",track,l,j);
00745           formulate(name,expr);
00746         }
00747 
00748         // data(i), i=0,1, uses only 1 value.
00749         sprintf(name,"Xi.topologyMap%s.data(%d)",track,l);
00750         sprintf(expr,"Xi.mTopologyMap%s.mMap%d",track,l);
00751         formulate(name,expr);
00752       }
00753 
00754       // ftpcFormat()
00755       sprintf(ftpc,"Xi.topologyMap%s.ftpcFormat()",track);
00756       sprintf(expr,"Xi.topologyMap%s.bit(63)",track);
00757       formulate(ftpc,expr);
00758 
00759       // primaryVertexUsed()
00760       sprintf(name,"Xi.topologyMap%s.primaryVertexUsed()",track);
00761       sprintf(expr,"Xi.topologyMap%s.bit(0)",track);
00762       formulate(name,expr);
00763 
00764       // turnAroundFlag()
00765       sprintf(name,"Xi.topologyMap%s.turnAroundFlag()",track);
00766       sprintf(expr,"Xi.topologyMap%s.bit(62)",track);
00767       formulate(name,expr);
00768 
00769       // hasHitInSvtLayer(i), i=1,6
00770       for (int j=1; j<7; j++) {
00771         sprintf(name,"Xi.topologyMap%s.hasHitInSvtLayer(%d)",track,j);
00772         sprintf(temp,"Xi.topologyMap%s.bit(%d)\0",track,j);
00773         sprintf(expr,"(!%s)&&(%s)\0",ftpc,temp);
00774         formulate(name,expr);
00775         
00776         tstr += temp;
00777         if (j<6) tstr += "+";
00778       }
00779 
00780       // numOfSvtHits(), uses 6 values
00781       sprintf(name,"Xi.topologyMap%s.numOfSvtHits()\0",track);
00782       sprintf(expr,"(!%s)*(%s)\0",ftpc,tstr.Data());
00783       formulate(name,expr);
00784       tstr = "";
00785       
00786       // hasHitInSSD()
00787       sprintf(name,"Xi.topologyMap%s.hasHitInSSD()",track);
00788       sprintf(expr,"Xi.topologyMap%s.bit(7)",track);
00789       formulate(name,expr);
00790 
00791       sprintf(temp,"(!%s)*(\0",ftpc);
00792       tstr = temp;
00793 
00794       // hasHitInTpcRow(i), i=0,44
00795       for (int j=0; j<45; j++) {
00796         sprintf(name,"Xi.topologyMap%s.hasHitInTpcRow(%d)",track,j);
00797         int m = j+8;
00798         sprintf(temp,"Xi.topologyMap%s.bit(%d)\0",track,m);
00799         sprintf(expr,"(!%s)&&(%s)\0",ftpc,temp);
00800         formulate(name,expr);
00801         
00802         tstr += temp;
00803         if (j<44) tstr += "+";
00804       }
00805 
00806       // numOfTpcHits(), uses 45 values.
00807       sprintf(name,"Xi.topologyMap%s.numOfTpcHits()\0",track);
00808       tstr += ")";
00809       formulate(name,tstr.Data());
00810       tstr = "";
00811 
00812       // hasHitInMwpc()
00813       sprintf(name,"Xi.topologyMap%s.hasHitInMwpc()",track);
00814       sprintf(expr,"Xi.topologyMap%s.bit(53)",track);
00815       formulate(name,expr);
00816 
00817       // hasHitInCtb()
00818       sprintf(name,"Xi.topologyMap%s.hasHitInCtb()",track);
00819       sprintf(expr,"Xi.topologyMap%s.bit(54)",track);
00820       formulate(name,expr);
00821 
00822       // hasHitInTofPatch()
00823       sprintf(name,"Xi.topologyMap%s.hasHitInTofPatch()",track);
00824       sprintf(expr,"Xi.topologyMap%s.bit(55)",track);
00825       formulate(name,expr);
00826 
00827       // hasHitInRich()
00828       sprintf(name,"Xi.topologyMap%s.hasHitInRich()",track);
00829       sprintf(expr,"Xi.topologyMap%s.bit(56)",track);
00830       formulate(name,expr);
00831 
00832       // hasHitInBarrelEmc()
00833       sprintf(name,"Xi.topologyMap%s.hasHitInBarrelEmc()",track);
00834       sprintf(expr,"Xi.topologyMap%s.bit(57)",track);
00835       formulate(name,expr);
00836 
00837       // hasHitInEndcapEmc()
00838       sprintf(name,"Xi.topologyMap%s.hasHitInEndcapEmc()",track);
00839       sprintf(expr,"Xi.topologyMap%s.bit(58)",track);
00840       formulate(name,expr);
00841 
00842     } } // End topology maps
00843 
00844     // The following formulas use 1 value:
00845     formulate("Xi.chi2Xi()", "Xi.mChi2Xi");
00846     formulate("Xi.clXi()", "Xi.mClXi");
00847     formulate("Xi.chi2Bachelor()", "Xi.mChi2Bachelor");
00848     formulate("Xi.clBachelor()", "Xi.mClBachelor");
00849     formulate("Xi.dedxBachelor()", "Xi.mDedxBachelor");
00850     formulate("Xi.numDedxBachelor()", "Xi.mNumDedxBachelor");
00851 
00852   }  // End of Xi
00853 
00854   // XiMc
00855   if (tree->GetBranch("XiMc")) {
00856     printf("Loading XiMc formulas...\n");
00857 
00858     // The following formulas use 6 values:
00859     formulate("XiMc.decayLengthXi()",
00860       "sqrt(sq(XiMc.mPositionX-McEvent.mPrimaryVertexX[0])+sq(XiMc.mPositionY-McEvent.mPrimaryVertexY[0])+sq(XiMc.mPositionZ-McEvent.mPrimaryVertexZ[0]))");
00861 
00862     // The following formulas use 1 value:
00863     formulate("XiMc.decayMode()", "XiMc.mDecayMode");
00864     formulate("XiMc.commonTpcHits()", "XiMc.mCommonTpcHits");
00865     formulate("XiMc.simTpcHits()", "XiMc.mSimTpcHits");
00866     formulate("XiMc.geantIdParent()", "XiMc.mParentGeantId");
00867     formulate("XiMc.geantIdDaughter()", "XiMc.mDaughterGeantId");
00868     formulate("XiMc.parentMomentumX()", "XiMc.mParentMomentumX");
00869     formulate("XiMc.parentMomentumY()", "XiMc.mParentMomentumY");
00870     formulate("XiMc.parentMomentumZ()", "XiMc.mParentMomentumZ");
00871     formulate("XiMc.daughterMomentumX()", "XiMc.mDaughterMomentumX");
00872     formulate("XiMc.daughterMomentumY()", "XiMc.mDaughterMomentumY");
00873     formulate("XiMc.daughterMomentumZ()", "XiMc.mDaughterMomentumZ");
00874     formulate("XiMc.positionX()", "XiMc.mPositionX");
00875     formulate("XiMc.positionY()", "XiMc.mPositionY");
00876     formulate("XiMc.positionZ()", "XiMc.mPositionZ");
00877 
00878   }  // End of XiMc
00879 
00880 
00881   // Kink
00882   if (tree->GetBranch("Kink")) {
00883     printf("Loading Kink formulas...\n");
00884 
00885   }  // End of Kink
00886 
00887   // KinkMc
00888   if (tree->GetBranch("KinkMc")) {
00889     printf("Loading KinkMc formulas...\n");
00890 
00891     // The following formulas use 1 value:
00892     formulate("KinkMc.decayMode()", "KinkMc.mDecayMode");
00893     formulate("KinkMc.commonTpcHits()", "KinkMc.mCommonTpcHits");
00894     formulate("KinkMc.simTpcHits()", "KinkMc.mSimTpcHits");
00895     formulate("KinkMc.geantIdParent()", "KinkMc.mParentGeantId");
00896     formulate("KinkMc.geantIdDaughter()", "KinkMc.mDaughterGeantId");
00897     formulate("KinkMc.parentMomentumX()", "KinkMc.mParentMomentumX");
00898     formulate("KinkMc.parentMomentumY()", "KinkMc.mParentMomentumY");
00899     formulate("KinkMc.parentMomentumZ()", "KinkMc.mParentMomentumZ");
00900     formulate("KinkMc.daughterMomentumX()", "KinkMc.mDaughterMomentumX");
00901     formulate("KinkMc.daughterMomentumY()", "KinkMc.mDaughterMomentumY");
00902     formulate("KinkMc.daughterMomentumZ()", "KinkMc.mDaughterMomentumZ");
00903     formulate("KinkMc.positionX()", "KinkMc.mPositionX");
00904     formulate("KinkMc.positionY()", "KinkMc.mPositionY");
00905     formulate("KinkMc.positionZ()", "KinkMc.mPositionZ");
00906 
00907   }  // End of KinkMc
00908   
00909   Int_t finalFormulas = ListofFuncs->GetSize();
00910   return (finalFormulas-initialFormulas);
00911 
00912 }
00913 //______________________________________________________________________
00914 // $Id: strangeFormulas.C,v 3.12 2008/03/05 15:47:25 genevb Exp $
00915 // $Log: strangeFormulas.C,v $
00916 // Revision 3.12  2008/03/05 15:47:25  genevb
00917 // updated ROOT class for ListOfFunctions()
00918 //
00919 // Revision 3.11  2004/10/20 19:22:10  genevb
00920 // Compatibility with small ROOT and CINT changes
00921 //
00922 // Revision 3.10  2004/04/12 19:50:06  genevb
00923 // Allow use of list files
00924 //
00925 // Revision 3.9  2004/04/06 21:27:51  genevb
00926 // Avoid PmdCollection branch
00927 //
00928 // Revision 3.8  2004/01/06 05:21:22  genevb
00929 // Restore decay length functionality (was broken)
00930 //
00931 // Revision 3.7  2003/01/22 05:15:16  genevb
00932 // Use TChain for multiple files
00933 //
00934 // Revision 3.6  2002/05/17 14:07:55  genevb
00935 // Added some new event functions
00936 //
00937 // Revision 3.5  2002/04/30 01:29:18  genevb
00938 // Updated macros for common micro DST
00939 //
00940 // Revision 3.4  2001/05/04 21:17:57  genevb
00941 // Catch ROOT definition of TTreeFormula class, add McEvent branch
00942 //
00943 // Revision 3.3  2000/08/28 16:24:33  genevb
00944 // Introduce findFormula(), handle executing on second tree
00945 //
00946 // Revision 3.2  2000/08/11 17:09:05  genevb
00947 // Introduce findFormulas(), findDefinition(),  and some new formulas.
00948 //
00949 // Revision 3.1  2000/08/10 01:21:10  genevb
00950 // Added number of dedx points
00951 //
00952 // Revision 3.0  2000/07/17 22:08:11  genevb
00953 // Updated for rev. 3, fixed bug in number of tpc hits
00954 //
00955 // Revision 2.0  2000/06/09 22:13:45  genevb
00956 // Updated for version 2 of Strangeness mico DST package
00957 //
00958 // Revision 1.7  2000/04/19 15:11:15  genevb
00959 // Streamlined adding TTreeFormulas
00960 //
00961 // Revision 1.6  2000/04/13 19:33:44  genevb
00962 // Removed redundant formulas
00963 //
00964 // Revision 1.5  2000/04/13 18:30:26  genevb
00965 // Better handling of backward compatibility
00966 //
00967 // Revision 1.4  2000/04/12 21:13:27  genevb
00968 // Added track topology map functions
00969 //
00970 // Revision 1.3  2000/04/11 17:55:39  genevb
00971 // Removed first parameter
00972 //
00973 // Revision 1.2  2000/04/07 16:22:48  genevb
00974 // Remove ambiguity on supplying just one parameter
00975 //
00976 // Revision 1.1  2000/04/07 16:14:53  genevb
00977 // Introduction of strangeFormulas.C
00978 //