StRoot: StStrangeMuDstMaker/StStrangeMuDstMaker.cxx Source File

00001 
00002 //                                                                      //
00003 // StStrangeMuDstMaker strangeness micro DST maker                      //
00004 //                                                                      //
00006 #include "StStrangeMuDstMaker.h"
00007 #include "TFile.h"
00008 #include "TChain.h"
00009 #include "THack.h"
00010 #include "StTree.h"
00011 #include "StEvent/StEvent.h"
00012 #include "StEvent.h"
00013 #include "StStrangeEvMuDst.hh"
00014 #include "StStrangeCuts.hh"
00015 #include "StMcEventTypes.hh"
00016 #include "StParticleDefinition.hh"
00017 #include "StMessMgr.h"
00018 #include "StuJitterBug.hh"
00019 
00020 // Set maximum file size to 1.9 GB (Root has a 2GB limit)
00021 #define MAXFILESIZE 1900000000
00022 
00023 #define EachDoT(proc) \
00024   for (Int_t i=1; i<strDstT; i++) { \
00025     if (doT[i]) proc; }
00026 
00027 #define EachController(proc) EachDoT( if( cont[i]) cont[i]->proc );
00028 
00029 // Defaults file and tree names;
00030 static const char* defFileName = "evMuDst.root";
00031 static const char* defName = "StrangeMuDst";
00032 static const char* altName = "MuDst";
00033 static const char* defTitle = "Strangeness Micro-DST";
00034 static const char* trNames[3] = {defName,altName,0};
00035 
00036 Int_t thisRun,thisEvent,lastRun,lastEvent,readEventNumber;
00037 TFile* lastFile;
00038 
00039 ClassImp(StStrangeMuDstMaker)
00040 //_____________________________________________________________________________
00041 StStrangeMuDstMaker::StStrangeMuDstMaker(const char *name) : StMaker(name) {
00042 
00043   muDst = 0;
00044   tree = 0;
00045   chain = 0;
00046   evClonesArray = 0;
00047   evMcArray = 0;
00048   cutsArray = 0;
00049   dstMaker = 0;
00050   cuts = new StStrangeCuts();
00051   SetNumber(-2);
00052   outFileNum = 1;
00053   doT0JitterAbort = kFALSE;
00054 
00055   //printf("DEBUG :: >>>>>>>> %d \n",strDstT);
00056 
00057   for (Int_t i=0; i<strDstT; i++) {
00058     doT[i] = kFALSE;
00059     cont[i] = 0;
00060     bsize[i] = 0;
00061   }
00062 
00063   strcpy(file,defFileName);
00064   fileBlind = kFALSE;
00065 
00066   doMc = kFALSE;
00067   SetMode(StrangeNoFile);
00068   abortEvent = kFALSE;
00069 
00070   bsize[evT] = 64000;
00071 
00072   thisRun = -1;
00073   thisEvent = -1;
00074   lastRun = -1;
00075   lastEvent = -1;
00076   lastFile = 0;
00077 }
00078 //_____________________________________________________________________________
00079 StStrangeMuDstMaker::~StStrangeMuDstMaker() {
00080 
00081   if (!dstMaker) {           // Don't delete other maker's array!
00082     delete evClonesArray; evClonesArray = 0;
00083     if (evMcArray) { delete evMcArray; evMcArray = 0; }
00084   }
00085   delete cutsArray; cutsArray = 0;
00086   delete cuts; cuts = 0;
00087   for (int i=0;i<strDstT;i++) {delete cont[i]; cont[i]=0;}
00088 
00089 }
00090 //_____________________________________________________________________________
00091 Int_t StStrangeMuDstMaker::Init() {
00092 
00093   abortEvent = kFALSE;
00094   firstEvent = kTRUE;
00095   if (Debug()) gMessMgr->Debug() << "In StStrangeMuDstMaker::Init() ... "
00096                                << GetName() << endm; 
00097   if ((GetMode() == StrangeWrite) && (OpenFile() == kStErr)) return kStEOF;
00098   if (!dstMaker) {
00099     evClonesArray = new TClonesArray("StStrangeEvMuDst",1);
00100     if (doMc) evMcArray = new TClonesArray("StStrangeEvMuDst",1);
00101   }
00102   cutsArray = new TClonesArray("TCut",0);
00103   StStrangeControllerBase::currentMaker = this;
00104   {
00105     EachDoT(cont[i] = StStrangeControllerBase::Instantiate(i));
00106     //printf("DEBUG :: %d \n",strDstT);
00107     //for(Int_t i=1; i < strDstT; i++) printf("DEBUG :: %d\n",cont[i]);
00108   }
00109 
00110   v0 = cont[v0T];
00111   xi = cont[xiT];
00112   kink = cont[kinkT];
00113 
00114   if (GetMode() == StrangeNoKeep) {
00115     {EachDoT( cont[i]->SetBufferSize(32000) );}
00116   } else {
00117     {EachDoT( if (bsize[i]) cont[i]->SetBufferSize(bsize[i]) );}
00118   }
00119 
00120   if (GetMode() == StrangeRead) {            // READING  the Micro Dst
00121     InitReadDst();
00122     if (dstMaker) {
00123       gMessMgr->Error() << "StStrangeMuDstMaker: cannot read a dst and create "
00124                         << "a dst with one maker.\n"
00125                         << "  Will read only." << endm;
00126       dstMaker = 0;
00127     }
00128   } else {                            // CREATING the Micro Dst
00129     InitCreateDst();
00130   }
00131   
00132   return StMaker::Init();
00133 }
00134 //_____________________________________________________________________________
00135 void StStrangeMuDstMaker::InitReadDst() {
00136   
00137   if (!((tree) && (muDst))) {
00138     gMessMgr->Error(
00139       "StStrangeMuDstMaker: no appropriate tree in input file(s)!");
00140     return;
00141   }
00142 
00143   // 5/20/02 - GVB
00144   // Correct for a problem with setting branch file names in old MuDSTs.
00145   // Setting of branch file names has now been removed (never worked anyhow).
00146   if (strcmp(tree->GetBranch("Event")->GetFileName(),"")) {
00147     TObjArray* listOfBranches = tree->GetListOfBranches();
00148     for (int i=0; i<listOfBranches->GetEntriesFast(); i++)
00149       ((TBranch*) listOfBranches->At(i))->SetFile(muDst);
00150   }
00151 
00152   tree->SetBranchStatus("*",0);
00153   tree->SetBranchStatus("Event.*",1);
00154   tree->SetBranchAddress("Event",&evClonesArray);
00155   if (doMc) {
00156     tree->SetBranchStatus("McEvent.*",1);
00157     tree->SetBranchAddress("McEvent",&evMcArray);
00158   }
00159   EachController(InitReadDst());
00160 
00161   if (tree->GetBranch("StrangeCuts")) {
00162     tree->SetBranchStatus("StrangeCuts.*",1);
00163     tree->SetBranchAddress("StrangeCuts",&cutsArray);
00164   } else {
00165     TOrdCollection* ordCuts = (TOrdCollection*) muDst->Get("StrangeCuts");
00166     if (ordCuts) {
00167       cuts->Reset(ordCuts);
00168     } else {
00169       gMessMgr->Warning("StStrangeMuDstMaker: no StrangeCuts");
00170       cuts->UnknownCuts();
00171     }
00172   }
00173 
00174   if( Debug() ) {
00175     TObjArray *listOfBranches = tree->GetListOfBranches();
00176     for( Int_t i=0; i<tree->GetNbranches(); i++) {
00177       const char* n = ((TBranch*) listOfBranches->At(i))->GetName();
00178       gMessMgr->Debug() << "Branch " << n << " Status = " << tree->GetBranchStatus(n) << endm;
00179     }
00180   }
00181 }
00182 //_____________________________________________________________________________
00183 void StStrangeMuDstMaker::InitCreateDst() {
00184   
00185   tree = new TTree(defName,defTitle);
00186   tree->SetDirectory(muDst);
00187   EachController(InitCreateDst());
00188 
00189   Int_t split = 99;
00190   TBranch* branch = tree->Branch("StrangeCuts",&cutsArray,bsize[evT],split);
00191   if (!dstMaker) {
00192     branch = tree->Branch("Event",&evClonesArray,bsize[evT],split);
00193     if (doMc) {
00194       branch = tree->Branch("McEvent",&evMcArray,bsize[evT],split);
00195     }
00196   }
00197 
00198   if (firstEvent) cuts->Init();
00199 }
00200 //_____________________________________________________________________________
00201 void StStrangeMuDstMaker::InitCreateSubDst() {
00202 
00203   Int_t split=2;
00204   evClonesArray = dstMaker->GetEvClonesArray();
00205   TBranch* branch = tree->Branch("Event",&evClonesArray,bsize[evT],split);
00206   if (doMc) {
00207     evMcArray = dstMaker->GetEvMcArray();
00208     branch = tree->Branch("McEvent",&evMcArray,bsize[evT],split);
00209   }
00210   EachController(InitCreateSubDst());
00211 }
00212 //_____________________________________________________________________________
00213 Int_t StStrangeMuDstMaker::Make() {
00214 
00215   if (Debug()) gMessMgr->Debug() << "In StStrangeMuDstMaker::Make() ... "
00216                                << GetName() << endm; 
00217 
00218   if (GetMode() == StrangeRead) {            // READING  the Micro Dst
00219     return MakeReadDst();
00220   } else if (!dstMaker) {             // CREATING a new Micro Dst
00221     return MakeCreateDst();
00222     
00223   // Else creating a sub-Micro Dst, done in the Clear() stage.
00224   // However, since the old Micro Dst's Init() is called AFTER the new
00225   // one's, special initialization for the subDST must be done on the
00226   // first time through Make().
00227   } else if (!evClonesArray) {
00228     InitCreateSubDst();
00229   }
00230   return kStOK;
00231 }
00232 //_____________________________________________________________________________
00233 Int_t StStrangeMuDstMaker::MakeReadDst() {
00234 
00235   if (!((tree) && (muDst))) return kStEOF;
00236   Int_t makerEventNumber = GetNumber();
00237   if (makerEventNumber == -2) {    // If event numbers aren't supplied,
00238     readEventNumber = 0;           // start at 0 and increment ourselves.
00239     SetNumber(-1);                 // Use m_Number = -1 to indicate this.
00240   } else if (makerEventNumber == -1) {
00241     readEventNumber++;
00242   } else {
00243     readEventNumber = makerEventNumber;
00244   }
00245 
00246 
00247   if (tree->GetEvent(readEventNumber) <= 0) return kStEOF; // Read the event
00248 
00249   TFile* thisFile = chain->GetFile();
00250   if (thisFile != lastFile) {
00251     gMessMgr->Info() << "StStrangeMuDstMaker: Now reading from event file:\n  "
00252         << thisFile->GetName() << endm;
00253     lastFile = thisFile;
00254   }
00255 
00256   // Overcome a bug where event wasn't meant to be recorded into a muDst,
00257   // but was anyhow (with the previous event's info, or none at all)
00258   Bool_t badEvent = kTRUE;
00259   if (GetEvent()) { 
00260     thisRun = GetEvent()->run();
00261     thisEvent = GetEvent()->event();
00262     badEvent = (thisRun == lastRun) && (thisEvent == lastEvent);
00263   }
00264   if (badEvent) {
00265     if (makerEventNumber < 0 ) {
00266       // User is calling Make() (not asking for a specific event).
00267       // Automatically skip to next event.
00268       return MakeReadDst();
00269     } else {
00270       // User is calling Make(i) (asking for a specific event i).
00271       // Return a "cleared" event.
00272       gMessMgr->Warning() <<
00273         "StStrangeMuDstMaker: event on file has bad event info\n" <<
00274         "    and should be skipped!" << endm;
00275       GetEvent()->Clear();
00276       EachController(Clear());
00277       return kStOK;
00278       //return kStSkip;
00279     }
00280   } else {
00281     lastRun = thisRun;
00282     lastEvent = thisEvent;
00283   }
00284 
00285   if (cutsArray->GetEntriesFast()) cuts->Reset(cutsArray);
00286 
00287   EachController(MakeReadDst());
00288  
00289   return kStOK;
00290 }
00291 //_____________________________________________________________________________
00292 Int_t StStrangeMuDstMaker::MakeCreateDst() {
00293 
00294   if (abortEvent) return kStOK;
00295 
00296   // Get the cut parameters and fill StrangeCuts on the first event
00297   if (firstEvent) {
00298     Int_t iSize = cuts->GetSize();
00299     cuts->Fill(strTypeNames[v0T], GetDataSet("ev0par2"));
00300     cuts->Fill(strTypeNames[xiT], GetDataSet("exipar"));
00301     cuts->Fill(strTypeNames[kinkT], GetDataSet("tkf_tkfpar"));
00302     Int_t fSize = cuts->GetSize();
00303     if (!(fSize-iSize)) {
00304       gMessMgr->Warning("StStrangeMuDstMaker: no cut parameters found.");
00305       cuts->UnknownCuts();
00306     }
00307     firstEvent = kFALSE;
00308   }  
00309 
00310   // Get event
00311   StEvent* event = (StEvent*) GetInputDS("StEvent");
00312   if (!event) return kStOK; 
00313 
00314   new((*evClonesArray)[0]) StStrangeEvMuDst(*event);
00315   cuts->UpdateArray(cutsArray);
00316 
00317   if (doT0JitterAbort && t0JitterAbort(event)) {
00318     gMessMgr->Warning("StStrangeMuDstMaker: T0 jitter; skipping event.");
00319     return kStWarn;
00320   }
00321 
00322   EachController(MakeCreateDst(*event));
00323   if (doMc) MakeCreateMcDst();
00324 
00325   CheckFile();
00326   tree->Fill();
00327 
00328   return kStOK;
00329 }
00330 //_____________________________________________________________________________
00331 Int_t StStrangeMuDstMaker::MakeCreateMcDst() {
00332 
00333   gMessMgr->Info("StStrangeMuDstMaker::MakeCreateMcDst(): running...");
00334   
00335   StMcEvent* mcEvent = (StMcEvent*) GetDataSet("StMcEvent");
00336   if (!mcEvent)   {
00337     gMessMgr->Error() << "StStrangeMuDstMaker: no StMcEvent! \n" 
00338          << " mc branch and assoc branch  will not be filled. " << endm;       
00339     return 0;
00340   }
00341   new((*evMcArray)[0]) StStrangeEvMuDst(*mcEvent);
00342   if (!GetMaker("StAssociationMaker")) {
00343     gMessMgr->Warning() << "StStrangeMuDstMaker: no associated info! \n" 
00344                       << " assoc branch will not be filled. " << endm;
00345   }
00346 
00347   //Loop over all MC vertices
00348   StSPtrVecMcVertex& mcVertices = mcEvent->vertices();
00349   for (StMcVertexIterator mcVertexIt = mcVertices.begin();
00350                           mcVertexIt != mcVertices.end(); mcVertexIt++) {
00351     const StMcTrack* parent = (*mcVertexIt)->parent();
00352     if (parent) switch (parent->geantId()) {
00353 
00354       // Xi vertex candidates
00355       case (23) : // Xi-
00356       case (31) : // AntiXi+
00357       case (24) : // Omega-
00358       case (32) : // AntiOmega+
00359         if (doT[xiT]) cont[xiT]->MakeCreateMcDst(*mcVertexIt);
00360         break;
00361 
00362       // V0 vertex candidates
00363       case (10) : // Kaon0Long
00364       case (16) : // Kaon0Short
00365       case (18) : // Lambda
00366       case (26) : // AntiLambda
00367         // Do all V0's here only if not doing Xi's
00368         if (doT[v0T] && !(doT[xiT])) cont[v0T]->MakeCreateMcDst(*mcVertexIt);
00369         break;
00370 
00371       // Kink vertex candidates
00372       case ( 5) : // Muon+
00373       case ( 6) : // Muon-
00374       case ( 8) : // Pion+
00375       case ( 9) : // Pion-
00376       case (11) : // Kaon+
00377       case (12) : // Kaon-
00378         // Keep all kinks
00379         if (doT[kinkT]) cont[kinkT]->MakeCreateMcDst(*mcVertexIt);
00380         break;
00381 
00382       default   : {}
00383     }
00384   }//end of loop over MC  vertices
00385 
00386   // If doing Xi's, all Xi V0 daughters are done concurrently with their Xi.
00387   // Do all non-Xi V0's at the end...
00388   if (doT[xiT] && doT[v0T]) {
00389     for (StMcVertexIterator mcVertexIt = mcVertices.begin();
00390                           mcVertexIt != mcVertices.end(); mcVertexIt++) {
00391       Bool_t notFromXi = kTRUE;
00392       const StMcTrack* parent = (*mcVertexIt)->parent();
00393       if (parent) switch (parent->geantId()) {
00394         case (18) : // Lambda
00395         case (26) : // AntiLambda
00396           { // Check for cascade parentage
00397             const StMcTrack* parent2 = parent->parent();
00398             if (parent2) switch (parent2->geantId()) {
00399               case (23) : // Xi-
00400               case (31) : // AntiXi+
00401               case (24) : // Omega-
00402               case (32) : // AntiOmega+
00403                 notFromXi = kFALSE;
00404               default   : {}
00405             }
00406           }
00407         case (10) : // Kaon0Long
00408         case (16) : // Kaon0Short
00409           if (notFromXi) cont[v0T]->MakeCreateMcDst(*mcVertexIt);
00410         default   : {}
00411       }
00412     }
00413   }//end of loop over MC  vertices
00414   EachController(PrintNumMc());
00415 
00416   return kStOK;
00417 }
00418 //_____________________________________________________________________________
00419 Int_t StStrangeMuDstMaker::MakeCreateSubDst() {
00420 
00421   if (abortEvent) return kStOK;
00422 
00423   EachController(MakeCreateSubDst());
00424   CheckFile();
00425   cuts->Reset(dstMaker->Cuts());
00426   cuts->UpdateArray(cutsArray);
00427   tree->Fill();
00428 
00429   return kStOK;
00430 }
00431 //_____________________________________________________________________________
00432 void StStrangeMuDstMaker::Clear(Option_t *option) {
00433 
00434   if (Debug()) gMessMgr->Debug() << "In StStrangeMuDstMaker::Clear() ... "
00435                                << GetName() << endm; 
00436 
00437   for (Int_t i=0; i<subMakers.GetEntries(); i++) {
00438     StStrangeMuDstMaker* subMaker = (StStrangeMuDstMaker*) (subMakers[i]);
00439     subMaker->ClearForReal(option);
00440   }
00441   if (!dstMaker) {
00442     ClearForReal(option);
00443   }
00444 }
00445 //_____________________________________________________________________________
00446 void StStrangeMuDstMaker::ClearForReal(Option_t *option) {
00447 
00448   if (Debug()) gMessMgr->Debug() <<
00449     "In StStrangeMuDstMaker::ClearForReal() ... " << GetName() << endm; 
00450 
00451   if (tree) {
00452     if (dstMaker) {                                   // Making a subDST
00453       MakeCreateSubDst();
00454     } else {
00455       if (evClonesArray) THack::ClearClonesArray(evClonesArray);      // Not if making a subDST
00456       if (evMcArray) THack::ClearClonesArray(evMcArray);              // Not if making a subDST
00457     }
00458     THack::ClearClonesArray(cutsArray);
00459 
00460     EachController(Clear());
00461     if (GetMode() == StrangeNoKeep) tree->Reset();
00462   }
00463 
00464   abortEvent = kFALSE;
00465   StMaker::Clear(option);
00466 }
00467 //_____________________________________________________________________________
00468 Int_t StStrangeMuDstMaker::Finish() {
00469 
00470   if (Debug()) gMessMgr->Debug() << "In StStrangeMuDstMaker::Finish() ... "
00471                                << GetName() << endm; 
00472   if (GetMode() == StrangeWrite) CloseFile();
00473   //printf("DEBUG :: >>>>>>>> %d \n",strDstT);  
00474   EachController(Finish());
00475 
00476   return kStOK;
00477 }
00478 //_____________________________________________________________________________
00479 void StStrangeMuDstMaker::SetWrite(const char* eFile) {
00480   SetMode(StrangeWrite);
00481   SetFile(eFile);
00482 }
00483 //_____________________________________________________________________________
00484 void StStrangeMuDstMaker::SetRead(const char* eFile, const char* treeName) {
00485   SetMode(StrangeRead);
00486   if (!eFile) eFile = defFileName;
00487 
00488   // If we already have a muDst file, we're all set on TTree names
00489   if (!muDst) {
00490     if (!treeName) treeName = altName;
00491     else fileBlind = kTRUE;       // don't read file headers beforehand
00492     
00493     if (!tree) tree = (TTree*) (chain = new TChain(treeName,defTitle));
00494     else SetTreeName(treeName);
00495   }
00496   
00497   // Try to add the file
00498   Int_t nEntries = (Int_t) chain->GetEntriesFast();
00499   if (fileBlind) chain->Add(eFile);
00500   else chain->Add(eFile,0);
00501 
00502   cuts->ForceUpdateArray();
00503 
00504   // If we already have an appropriate TTree and file specified, we're done
00505   if (muDst) return;
00506 
00507   // If a TTree name was specified (so we continue blindly: faster, but
00508   //   there are no checks that a file is problematic until we reach it)...
00509   if (fileBlind) { muDst = chain->GetFile(); return; }
00510 
00511   // Have not yet found an appropriate TTree - attempting to find one
00512   // GetEntries() will increase if the tree is found
00513   Int_t nEnt = (Int_t) chain->GetEntries();
00514   if (nEnt == TChain::kBigNumber) {
00515     gMessMgr->Error("StStrangeMuDstMaker::SetRead(): bad file! Giving up.");
00516     return;
00517   }
00518 
00519   Int_t trial=0;
00520   while (nEnt==nEntries) {
00521     if (trNames[trial]==0) { SetTreeName(treeName); return; } // No tree found
00522     // Trying other names until we succeed...
00523     if (strcmp(treeName,trNames[trial])) {
00524       SetTreeName(trNames[trial]);
00525       chain->Add(eFile,0);
00526       nEnt = (Int_t) chain->GetEntries();
00527     }
00528     trial++;
00529   }
00530 
00531   muDst = chain->GetFile();
00532 }
00533 //_____________________________________________________________________________
00534 void StStrangeMuDstMaker::SetRead(StFile* eFiles, const char* treeName) {
00535   SetMode(StrangeRead);
00536   while (!(eFiles->GetNextBundle()))
00537     SetRead(eFiles->GetFileName(0),treeName);
00538 }
00539 //_____________________________________________________________________________
00540 void StStrangeMuDstMaker::SetNoKeep() {
00541   SetMode(StrangeNoKeep);
00542 }
00543 //_____________________________________________________________________________
00544 void StStrangeMuDstMaker::SetFile(const char* eFile) {
00545   if (eFile) strcpy(file,eFile);
00546 }
00547 //_____________________________________________________________________________
00548 void StStrangeMuDstMaker::SetTreeName(const char* treeName) {
00549   if ((treeName) && (strcmp(treeName,tree->GetName()))) {
00550     tree->SetName(treeName);
00551     TObjArray* chainElems = chain->GetListOfFiles();
00552     for (Int_t i=0; i<chainElems->GetEntriesFast(); i++)
00553       ((TNamed*) (chainElems->At(i)))->SetName(treeName);
00554   }
00555 }
00556 //_____________________________________________________________________________
00557 Int_t StStrangeMuDstMaker::OpenFile() {
00558   if( ! (muDst = new TFile(file,"RECREATE")) ) {
00559     gMessMgr->Error() << "StStrangeMuDstMaker: Error opening event file:\n  "
00560                       << file << endm;
00561     return kStErr;
00562   }
00563 
00564   gMessMgr->Info() << "StStrangeMuDstMaker: Opened file for writing:\n"
00565                    << file << endm;     
00566   cuts->ForceUpdateArray();
00567   return kStOk;
00568 }
00569 //_____________________________________________________________________________
00570 Int_t StStrangeMuDstMaker::CloseFile() {
00571   if (muDst) {
00572     muDst->Write();
00573     muDst->cd();
00574     muDst->Close();
00575     tree = 0;
00576   }
00577   return kStOk;
00578 }
00579 //_____________________________________________________________________________
00580 void StStrangeMuDstMaker::CheckFile() {
00581   if (muDst) {
00582     if (muDst->GetBytesWritten() > MAXFILESIZE) {
00583       gMessMgr->Warning() << "StStrangeMuDstMaker: File size limit "
00584                           << MAXFILESIZE << " exceeded!\n"
00585                           << "           Closing file " << file << endm;
00586       CloseFile();
00587       char buf_[10];
00588       sprintf(buf_,"_%d",(++outFileNum));
00589         TString fixer = file;
00590         if (outFileNum>2) {
00591           TString suffix = strrchr(file,'.');
00592           size_t last_ = fixer.Last('_');
00593           size_t len_ = fixer.Length() - last_;
00594           fixer.Remove(last_,len_).Append(buf_).Append(suffix);
00595         } else {
00596           size_t lastdot = fixer.Last('.');
00597           fixer.Insert(lastdot,buf_);
00598         }
00599         strcpy(file,fixer.Data());
00600       OpenFile();
00601       InitCreateDst();
00602       if (dstMaker) InitCreateSubDst();
00603     }
00604   }
00605 }
00606 //_____________________________________________________________________________
00607 void StStrangeMuDstMaker::SelectEvent() {
00608   EachController(Select(-1));
00609 }
00610 //_____________________________________________________________________________
00611 void StStrangeMuDstMaker::UnselectEvent() {
00612   EachController(Unselect(-1));
00613 }
00614 //_____________________________________________________________________________
00615 void StStrangeMuDstMaker::SubDst(StStrangeMuDstMaker* maker) {
00616   dstMaker = maker;
00617   if (!(maker->subMakers.FindObject((TObject*) this)))
00618     maker->subMakers.Add(this);
00619 }
00620 //_____________________________________________________________________________
00621 void StStrangeMuDstMaker::SetCorrectionFile(char* fname) {
00622   StStrangeEvMuDst::SetCorrectionFile(fname);
00623 }
00624 //_____________________________________________________________________________
00625 void StStrangeMuDstMaker::SetFractionFile(char* fname) {
00626   StStrangeEvMuDst::SetFractionFile(fname);
00627 }
00628 //_____________________________________________________________________________
00629 char* StStrangeMuDstMaker::GetFile() {
00630   if (chain) {
00631     TFile* fptr = chain->GetFile();
00632     if (fptr) return const_cast<char*> (fptr->GetName());
00633   }
00634   return file;
00635 }       
00636 
00637 //_____________________________________________________________________________
00638 // $Id: StStrangeMuDstMaker.cxx,v 3.35 2009/09/02 19:39:44 genevb Exp $
00639 // $Log: StStrangeMuDstMaker.cxx,v $
00640 // Revision 3.35  2009/09/02 19:39:44  genevb
00641 // Fixes to pointer and string conversions (RT ticket 1612), prep for 64-bit
00642 //
00643 // Revision 3.34  2005/09/27 20:32:22  genevb
00644 // New method for StMcEvent access
00645 //
00646 // Revision 3.33  2004/11/02 17:54:07  genevb
00647 // Leave corrupt file protection to ROOT / Remove my protection
00648 //
00649 // Revision 3.32  2004/10/13 16:41:19  genevb
00650 // Use kStEOF returns to terminate chain
00651 //
00652 // Revision 3.31  2004/08/19 19:55:52  perev
00653 // Replace Delete to THack:ClearClone
00654 //
00655 // Revision 3.30  2004/07/12 21:45:34  genevb
00656 // Handle missing Event branch info condition
00657 //
00658 // Revision 3.29  2003/12/07 00:49:40  genevb
00659 // Include events with no primary vertex
00660 //
00661 // Revision 3.28  2003/11/13 02:57:08  perev
00662 // LeakOff TClonesArray::Clear() ==> Delete()
00663 //
00664 // Revision 3.27  2003/11/10 04:06:47  perev
00665 // delete controllers added in dtr
00666 //
00667 // Revision 3.26  2003/07/09 21:58:30  genevb
00668 // Use Get/SetMode() from StMaker
00669 //
00670 // Revision 3.25  2003/05/14 00:12:41  jones
00671 // Stops if StFile input file doesn't exist. Added some debugging info on branch status
00672 //
00673 // Revision 3.24  2003/03/20 00:26:05  jeromel
00674 // Logic correction ; can't call a method if no instance
00675 //
00676 // Revision 3.23  2003/02/10 17:55:55  genevb
00677 // Output currently read file
00678 //
00679 // Revision 3.22  2003/02/10 16:02:24  genevb
00680 // Now read files using TChains; no splitting of MuDst file
00681 //
00682 // Revision 3.21  2003/01/16 20:38:36  genevb
00683 // Reduce buffer size for NoKeep option
00684 //
00685 // Revision 3.20  2002/06/21 02:43:59  genevb
00686 // handle events without primary vertex better
00687 //
00688 // Revision 3.19  2002/06/19 15:08:40  genevb
00689 // Allow all MC kinks to be kept
00690 //
00691 // Revision 3.18  2002/05/29 19:08:16  genevb
00692 // Better handling of improperly closed files
00693 //
00694 // Revision 3.17  2002/05/20 21:37:12  genevb
00695 // Fixed problem with file names for branches
00696 //
00697 // Revision 3.16  2002/05/10 20:59:31  genevb
00698 // Fixed bug with branch status and changed cuts split level
00699 //
00700 // Revision 3.15  2002/04/30 16:02:48  genevb
00701 // Common muDst, improved MC code, better kinks, StrangeCuts now a branch
00702 //
00703 // Revision 3.14  2001/11/05 23:41:06  genevb
00704 // Add more dEdx, B field info, careful of changes to TTree unrolling
00705 //
00706 // Revision 3.13  2001/09/14 21:39:02  genevb
00707 // Adjustments to not depend on order in which maker Clear() is called
00708 //
00709 // Revision 3.12  2001/08/23 13:20:55  genevb
00710 // Many bug workarounds...
00711 //
00712 // Revision 3.11  2001/05/04 20:15:14  genevb
00713 // Common interfaces and reorganization of components, add MC event info
00714 //
00715 // Revision 3.10  2001/04/25 18:20:53  perev
00716 // HPcorrs
00717 //
00718 // Revision 3.9  2001/01/30 04:06:54  genevb
00719 // Better handling of file switches
00720 //
00721 // Revision 3.8  2001/01/04 01:03:23  genevb
00722 // Add CheckFile() for creating sub-dsts
00723 //
00724 // Revision 3.7  2000/12/18 21:35:18  genevb
00725 // Introduced variable buffer-sizing
00726 //
00727 // Revision 3.6  2000/10/27 21:55:31  genevb
00728 // Allow use of event.root files
00729 //
00730 // Revision 3.5  2000/09/28 20:16:05  jones
00731 // Added doT0JitterAbort() optio; added fix to CheckFile in case of no file
00732 //
00733 // Revision 3.4  2000/09/07 02:22:09  genevb
00734 // Added AbortEvent() functionality
00735 //
00736 // Revision 3.3  2000/08/10 01:14:17  genevb
00737 // Upped basket size of event branch; Set old file format
00738 //
00739 // Revision 3.2  2000/07/17 20:28:40  genevb
00740 // File size limitation workaround, some under the hood improvements
00741 //
00742 // Revision 3.1  2000/07/14 21:28:34  genevb
00743 // Added V0Mc index for XiMc, fixed bug with entries for XiMc, cleaned up controllers
00744 //
00745 // Revision 3.0  2000/07/14 12:56:49  genevb
00746 // Revision 3 has event multiplicities and dedx information for vertex tracks
00747 //
00748 // Revision 2.1  2000/06/09 22:17:10  genevb
00749 // Allow MC data to be copied between DSTs, other small improvements
00750 //
00751 // Revision 2.0  2000/06/02 22:11:54  genevb
00752 // New version of Strangeness micro DST package
00753 //
00754 // Revision 1.8  2000/04/27 14:17:34  genevb
00755 // Safer deletes
00756 //
00757 // Revision 1.7  2000/04/27 14:13:04  genevb
00758 // Added old tree deletion
00759 //
00760 // Revision 1.6  2000/04/18 02:30:04  genevb
00761 // Added multi-file capabilities
00762 //
00763 // Revision 1.5  2000/04/07 18:18:30  genevb
00764 // Additional crash protection
00765 //
00766 // Revision 1.4  2000/04/06 14:51:11  genevb
00767 // Fixed bug with storing event info when making subDST
00768 //
00769 // Revision 1.3  2000/04/05 20:23:53  genevb
00770 // Introduce creating sub-Micro DSTs, dynamic expansion of clones arrays as needed, SetNoKeep() function
00771 //
00772 // Revision 1.2  2000/03/29 20:52:13  genevb
00773 // Added StKinkMuDst, replaced arrays
00774 //
00775 // Revision 1.1  2000/03/29 03:10:07  genevb
00776 // Introduction of Strangeness Micro DST package
00777 //