TreeMod/src/Analysis.cc

// $Id: Analysis.cc,v 1.15 2008/09/28 02:36:23 loizides Exp $

#include "MitAna/TreeMod/interface/Analysis.h"
#include <Riostream.h>
#include <TFile.h>
#include <TList.h>
#include <TDSet.h>
#include <TChain.h>
#include <TObjString.h>
#include <TSystem.h>
#include <TProof.h>
#include <TROOT.h>
#include <TBrowser.h>
#include "MitAna/DataUtil/interface/Debug.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitAna/TAM/interface/TAMVirtualLoader.h"
#include "MitAna/TAM/interface/TAModule.h"
#include "MitAna/TreeMod/interface/Selector.h"
#include "MitAna/TreeMod/interface/TreeLoader.h"
#include "MitAna/TreeMod/interface/HLTFwkMod.h"
#include "MitAna/Catalog/interface/Dataset.h"

ClassImp(mithep::Analysis)

using namespace mithep;

//--------------------------------------------------------------------------------------------------
Analysis::Analysis(Bool_t useproof) : 
  fUseProof(useproof), 
  fUseHLT(kTRUE),
  fHierarchy(kTRUE), 
  fDoProxy(kTRUE), 
  fState(kPristine), 
  fNFriends(0), 
  fList(new TList), 
  fOutput(0), 
  fPackages(new TList), 
  fLoaders(new TList),
  fSuperMod(0), 
  fSelector(0), 
  fChain(0), 
  fSet(0), 
  fDeleteList(new TList),
  fTreeName(Names::gkEvtTreeName),
  fCompLevel(2), 
  fProof(0),
  fDoNEvents(TChain::kBigNumber)
{
  // Default constructor.

  fList->SetOwner();
  fDeleteList->SetOwner();

  /* default packages for PROOF upload */
  fPackages->SetOwner();
  // nothing to be done since we do not use par files (yet?)
}

//--------------------------------------------------------------------------------------------------
Analysis::~Analysis()
{
  // Destructor.

  if (fState == kInit || fState == kRun)
    Terminate();

  delete fList;
  delete fPackages;
  delete fLoaders;
  delete fDeleteList;
  delete fSelector;
  fOutput   = 0;   // owned by TAM
  fSuperMod = 0;   // owned by user

  delete fProof;
}

//--------------------------------------------------------------------------------------------------
Bool_t Analysis::AddFile(const char *pname)
{
  // Add file with given name to the list of files to be processed. Using the token "|", you can
  // specify an arbritray number of paths to tree files that will be concatenated as friend trees.

  if (fState != kPristine) {
    Error("AddFile", "Analysis already initialized");
    return kFALSE;
  }

  TString pnamestr(pname);
  TString tok("|");
  TObjArray *arr = pnamestr.Tokenize(tok);
  TString msg;

  for(Int_t i=0; i<arr->GetEntries(); i++){
      
    TObjString *dummy = dynamic_cast<TObjString*>(arr->At(i));
    if(!dummy) continue;

    AddFile(dummy->GetName(),i);      
    if(i==0) msg=dummy->GetName();
    else {
      Info("AddFile", "Add file %s as friend to %s", 
           dummy->GetName(), msg.Data());
    }
  }
  delete arr;

  return kTRUE;
}

//--------------------------------------------------------------------------------------------------
void Analysis::AddFile(const char *pname, Int_t eventlist)
{
  // Add file name to the event list specified by eventlist. The lists are used to hold filenames of
  // different types of events. In case you dont want friend trees, just give no eventlist argument
  // (default 0).

  MitAssert("AddFile", pname != 0);

  TList *l = 0;
  if (eventlist >= 0 && eventlist < fNFriends) {
      
    l = dynamic_cast<TList*>(fList->At(eventlist));
    if (!l) {
      Fatal("AddFile", "Requested list %d not found!", eventlist);
      return;
    }

  } else if (eventlist == fNFriends) {
      
    l = new TList;
    l->SetOwner();
    fList->Add(l);
    fNFriends++;

  } else if (eventlist < 0 || eventlist > fNFriends) {
    Error("AddFile", "Specified list %d not in [0,%d]", eventlist, fNFriends);
    return;
  }
   
  if(!IsValidName(pname)) return;

  l->Add(new TObjString(pname));

  MDB(kAnalysis, 2)
    Info("AddFile", "Added %s to list of files.", pname);
}

//--------------------------------------------------------------------------------------------------
void Analysis::AddFile(const TObject *oname, Int_t eventlist)
{
  // Add file name to the event list specified by eventlist. The lists are used to hold filenames of
  // different types of events. In case you dont want mixing, just give no eventlist argument
  // (default 0).

  MitAssert("AddFile", oname != 0);

  return AddFile(oname->GetName(), eventlist);
}

//________________________________________________________________________
Bool_t Analysis::AddFiles(const char *pname, Int_t nmax)
{
  // Add files from text file with given name. If nmax>0, maximum nmax files will be added.

  MitAssert("AddFiles", pname != 0);

  ifstream in;
  in.open(pname);
  if (!in) {
    Error("AddFiles", "Can not open file with name %s", pname);
    return kFALSE;
  }

  Int_t fc = 0;
  while (in) {
    TString line;
    line.ReadLine(in);
    cout << line << endl;
    if (!line.EndsWith(".root")) 
      continue;
    cout << line << endl;

    if (!AddFile(line)) {
      Error("AddFiles", "Error adding file with name %s", line.Data());
      return kFALSE;
    }

    ++fc;
    if(nmax>0 && fc>=nmax) {
      Info("AddFiles", "Maximal number (%d) of files added", nmax);
      break;
    }
  } 

  return kTRUE;
}

//--------------------------------------------------------------------------------------------------
Bool_t Analysis::AddDataset(const Dataset *dataset)
{
  // Add a full dataset to the analysis.

  Bool_t status = true;

  for (UInt_t i=0; i<dataset->NFiles(); i++)
    status = (status && AddFile(dataset->FileUrl(i)));

  return status;
}

//--------------------------------------------------------------------------------------------------
void Analysis::AddList(TList *list, Int_t eventlist)
{
  // Add file name to the event list specified by eventlist. The lists are used to hold filenames of
  // different types of events. In case you dont want mixing, just give no eventlist argument
  // (default 0).

  MitAssert("AddList", list != 0);

  TIter next(list);                           
  while (TObject *obj = next())                                
    AddFile(obj->GetName(), eventlist);
}

//--------------------------------------------------------------------------------------------------
void Analysis::AddLoader(TAMVirtualLoader *l)      
{ 
  // Add loader to the list of loaders.

  fLoaders->Add(l); 
}

//--------------------------------------------------------------------------------------------------
void Analysis::AddPackage(const char* name)
{
  // Add package to the list of uploaded packages.

  MitAssert("AddPackage", name != 0);
  fPackages->Add(new TObjString(name));
}

//--------------------------------------------------------------------------------------------------
void Analysis::AddPackages(TList *list)
{
  // Add list of packages to the list of uploaded packages.

  MitAssert("AddPackage", list != 0);

  TIter next(list);
  while (TObject *obj = next()) {
    fPackages->Add(new TObjString(obj->GetName()));
  }
}

//--------------------------------------------------------------------------------------------------
Bool_t Analysis::Init()
{
  // Setup the TDSet and TChain to be used for the analysis with or without PROOF. If more than one
  // list of file names was given, friend trees are supported.

  if (fState == kRun || fState == kInit) {
    Error("Init", "Init in state %d is not possible! Call Terminate() first.",
          Int_t(fState));
    return kFALSE;
  }

  if (fNFriends <= 0) {
    Error("Init", "List of friend lists is empty!");
    return kFALSE;
  }

  if (!fSuperMod) {
    Error("Init", "Top-level TAM module is NULL!");
    return kFALSE;
  }

  if (fUseProof) { // first init our PROOF session
    if (!InitProof()) return kFALSE;
  }

  // we do this here instead in Terminate() so that 
  // we can browse the output even after Terminate()
  delete fSelector;
  fSelector = 0;

  fChain = new TChain(fTreeName); 
  fSet   = new TDSet("TTree",fTreeName);

  for(Int_t i=0; i<fNFriends; i++){

    TList *l = dynamic_cast<TList*>(fList->At(i));
    if (!l) {
      Fatal("Init", "List %d not found!", i);
      return kFALSE;
    }

    if (i == 0) {
      TIter next(l);                           
      while ( TObjString *obj = dynamic_cast<TObjString*>(next()) ) {
        fChain->Add(obj->GetName());
        fSet->Add(obj->GetName());
      }

    } else {

      TChain *chain = new TChain(fTreeName); 
      TDSet *set    = new TDSet("TTree",fTreeName);

      TIter next(l);                           
      while (TObjString *obj = dynamic_cast<TObjString*>(next())) {
        chain->Add(obj->GetName());
        set->Add(obj->GetName());
      }

      TString alias("TAMTREE_"); // aliases currently not used
      alias+=i;

      fChain->AddFriend(chain,alias.Data());
      fSet->AddFriend(set,alias.Data());

      fDeleteList->Add(chain);
      fDeleteList->Add(set);
    }

  }

  // create our customized loader plugin for TAM
  TreeLoader *bl = new TreeLoader;
  fLoaders->Add(bl);
  fDeleteList->Add(bl);

  // create our HLT framework module
  HLTFwkMod *hltmod = 0;
  if (fUseHLT) {
    hltmod = new HLTFwkMod;
    fDeleteList->Add(hltmod);
  }

  if (fUseProof) {

    if (hltmod) 
      fProof->AddInput(hltmod);

    fProof->AddInput(fSuperMod);
    fLoaders->SetName("TAM_LOADERS");
    fProof->AddInput(fLoaders);      

  } else {

    // when not running Proof, we must make a selector
    fSelector = new Selector; 
    fSelector->SetDoProxy(fDoProxy);
    if (hltmod) 
      fSelector->AddInput(hltmod);
    fSelector->AddInput(fSuperMod);
    MDB(kAnalysis, 2)
      fSelector->SetVerbosity(1);

    // pass loaders to selector
    TIter next(fLoaders);                           
    while ( TAMVirtualLoader *l = dynamic_cast<TAMVirtualLoader*>(next()) )
      fSelector->AddLoader(l);
  }

  fState = kInit;
  return kTRUE;
}

//--------------------------------------------------------------------------------------------------
Bool_t Analysis::InitProof()
{
  // Initialize PROOF connection.

  if(fProof && fProof->IsValid()) 
    return kTRUE;

  delete fProof;

  if (fMaster.Contains("rcf.bnl.gov")) {
    for(Int_t i=0;i<5;i++) {
      Warning("InitProof", "*** DID YOU RUN PROOF_KINIT? %d (5) ***", i);
      gSystem->Sleep(1000);
    }
  }

  MDB(kAnalysis, 1)
    Info("InitProof", "Starting PROOF on master %s with config %s",
         fMaster.Data(), fConfig.Data());

  fProof = dynamic_cast<TProof*>(TProof::Open(fMaster, fConfig));
  if (!fProof) {
    Error("InitProof", "Could not start PROOF!");
    return kFALSE;
  }

  MDB(kAnalysis, 3)
    gROOT->Print();

  //fProof->AddInput(new TNamed("PROOF_NewPacketizer",""));

  Bool_t ret=kTRUE;
  if (fPackages) {
    // tell Proof what additional libraries we will need on each worker computer
    ret = UploadPackages(fPackages);
  }

  return ret;
}

//--------------------------------------------------------------------------------------------------
void Analysis::Run()
{
  // Run the analysis on the created file set.

  if (fState == kPristine || fState == kRun) {
    Error("Run", "Run in state %d is not possible! Call Init() first.",
          Int_t(fState));
  }

  if (fUseProof) {

    MDB(kAnalysis, 1)
      Info("Run", "Start processing with PROOF...");

    fSet->Process("Selector","",fDoNEvents);

  } else {

    MDB(kAnalysis, 1)
      Info("Run", "Start processing (no PROOF)...");

    fChain->Process(fSelector,"",fDoNEvents);
  }

  MDB(kAnalysis, 1)
    Info("Run", "Processing complete!");

  fState = kRun;
}

//--------------------------------------------------------------------------------------------------
Bool_t Analysis::Run(Bool_t browse)
{
  // Execute analysis and open TBrowser if requested.

  if (Init()) {
    Run();
    Terminate();
    if (browse) {
      new TBrowser;
    }
    return kTRUE;
  }

  Error("Execute", "Could not initialize analysis.");
  return kFALSE;
}

//--------------------------------------------------------------------------------------------------
void Analysis::Terminate()
{
  // Terminate current analysis run.

  if (fState == kPristine || fState == kTerminate) {
    Error("Terminate", "Terminate in state %d is not possible! Call Init() first.",
          Int_t(fState));
    return;
  }

  if (fState == kRun) {

    if (fUseProof) {
      // the output list from Proof can (in principal) contain other objects
      // besides the module output hierarchy.
      TList* outputlist = fProof->GetOutputList();
      TIter nextOut(outputlist);
      while (TObject *obj = nextOut()) {
        if (obj->InheritsFrom(TAMOutput::Class())) {
          fOutput = dynamic_cast<TList*>(obj);
          break;
        }
      }

    } else {
      fOutput = fSelector->GetModOutput();
    }

    if (fOutput && !fAnaOutput.IsNull()) {
      TDirectory::TContext context(0); // automatically restore gDirectory

      std::auto_ptr<TFile> outf(TFile::Open(fAnaOutput,"recreate","", fCompLevel));
      if (outf.get() == 0) {
        Error("Terminate", "Could not open file %s for output!", fAnaOutput.Data());
      } else {
        MDB(kAnalysis, 1)
          Info("Terminate", "Saving output to %s!", fAnaOutput.Data());

        if (fHierarchy) 
          fOutput->Write(fOutput->GetName(),TObject::kSingleKey);       
        else 
          fOutput->Write();
               
      }
    }
  }

  delete fChain;
  delete fSet;
  fDeleteList->Delete();
}

//--------------------------------------------------------------------------------------------------
Bool_t Analysis::UploadPackages(TList *packages)
{
  // Upload list of par files to the server.

  MitAssert("UploadPackages", packages != 0);

  for (Int_t i=0; i<packages->GetEntries(); i++) {

    TObject* objstr = packages->At(i); 
    if (!objstr) {
      Error("InitProof", "Problem at package number %d!", i);
      return kFALSE;
    }

    TString packname = objstr->GetName();
    Int_t   en       = 0;
    if (packname.EndsWith("+")) { 
      en=1;
      packname.Resize(packname.Length()-1);
    }

    ifstream ftest(gSystem->ExpandPathName(packname.Data()),ios_base::binary);
    if (!ftest.good()) {
      Error("InitProof", "Could not open %s for upload!", packname.Data());
      return kFALSE;
    }

    if (fProof->UploadPackage(packname)<0) {
      Error("UploadPackage", "Upload for %s failed!", packname.Data());
      return kFALSE;
    }

    if (en == 1) {
      Int_t pos=packname.Last('/')+1;
      if (pos)
        packname.Remove(0,pos);
      if (fProof->EnablePackage(packname)<0) {
        Error("UploadPackage", "Enabling for %s failed!", packname.Data());
        return kFALSE;
      }
    }
  }

  return kTRUE;
}
Revision:	1.16
Committed:	Mon Oct 6 17:01:21 2008 UTC (16 years, 7 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_005
Changes since 1.15:	+5 -5 lines
Log Message:	Introduce autobranch switch. Default on. If you have trouble using this, use AutoBranchLoad(0) to toggle it off.
#	User	Rev	Content
1	loizides	1.16	// $Id: Analysis.cc,v 1.15 2008/09/28 02:36:23 loizides Exp $
2	loizides	1.1
3	loizides	1.9	#include "MitAna/TreeMod/interface/Analysis.h"
4	loizides	1.1	#include <Riostream.h>
5			#include <TFile.h>
6			#include <TList.h>
7			#include <TDSet.h>
8			#include <TChain.h>
9			#include <TObjString.h>
10			#include <TSystem.h>
11			#include <TProof.h>
12			#include <TROOT.h>
13	loizides	1.4	#include <TBrowser.h>
14	loizides	1.1	#include "MitAna/DataUtil/interface/Debug.h"
15	loizides	1.2	#include "MitAna/DataTree/interface/Names.h"
16	loizides	1.1	#include "MitAna/TAM/interface/TAMVirtualLoader.h"
17			#include "MitAna/TAM/interface/TAModule.h"
18	loizides	1.9	#include "MitAna/TreeMod/interface/Selector.h"
19	loizides	1.11	#include "MitAna/TreeMod/interface/TreeLoader.h"
20	loizides	1.15	#include "MitAna/TreeMod/interface/HLTFwkMod.h"
21	paus	1.13	#include "MitAna/Catalog/interface/Dataset.h"
22	loizides	1.1
23			ClassImp(mithep::Analysis)
24
25			using namespace mithep;
26
27	loizides	1.12	//--------------------------------------------------------------------------------------------------
28	loizides	1.5	Analysis::Analysis(Bool_t useproof) :
29			fUseProof(useproof),
30	loizides	1.15	fUseHLT(kTRUE),
31	loizides	1.16	fHierarchy(kTRUE),
32			fDoProxy(kTRUE),
33	loizides	1.5	fState(kPristine),
34			fNFriends(0),
35			fList(new TList),
36			fOutput(0),
37			fPackages(new TList),
38			fLoaders(new TList),
39			fSuperMod(0),
40			fSelector(0),
41			fChain(0),
42			fSet(0),
43			fDeleteList(new TList),
44	loizides	1.8	fTreeName(Names::gkEvtTreeName),
45	loizides	1.5	fCompLevel(2),
46			fProof(0),
47	paus	1.6	fDoNEvents(TChain::kBigNumber)
48	loizides	1.4	{
49			// Default constructor.
50
51			fList->SetOwner();
52			fDeleteList->SetOwner();
53
54			/* default packages for PROOF upload */
55			fPackages->SetOwner();
56			// nothing to be done since we do not use par files (yet?)
57	loizides	1.1	}
58
59	loizides	1.12	//--------------------------------------------------------------------------------------------------
60	loizides	1.1	Analysis::~Analysis()
61			{
62	loizides	1.4	// Destructor.
63	loizides	1.1
64	loizides	1.4	if (fState == kInit \|\| fState == kRun)
65			Terminate();
66	loizides	1.1
67	loizides	1.4	delete fList;
68	paus	1.7	delete fPackages;
69			delete fLoaders;
70	loizides	1.4	delete fDeleteList;
71			delete fSelector;
72			fOutput = 0; // owned by TAM
73			fSuperMod = 0; // owned by user
74	loizides	1.1
75	loizides	1.4	delete fProof;
76	loizides	1.1	}
77
78	loizides	1.12	//--------------------------------------------------------------------------------------------------
79	loizides	1.5	Bool_t Analysis::AddFile(const char *pname)
80	loizides	1.1	{
81	paus	1.7	// Add file with given name to the list of files to be processed. Using the token "\|", you can
82			// specify an arbritray number of paths to tree files that will be concatenated as friend trees.
83	loizides	1.4
84			if (fState != kPristine) {
85			Error("AddFile", "Analysis already initialized");
86			return kFALSE;
87			}
88
89			TString pnamestr(pname);
90			TString tok("\|");
91			TObjArray *arr = pnamestr.Tokenize(tok);
92			TString msg;
93	loizides	1.1
94	loizides	1.4	for(Int_t i=0; i<arr->GetEntries(); i++){
95	loizides	1.1
96	loizides	1.4	TObjString dummy = dynamic_cast<TObjString>(arr->At(i));
97			if(!dummy) continue;
98	loizides	1.1
99	loizides	1.4	AddFile(dummy->GetName(),i);
100			if(i==0) msg=dummy->GetName();
101			else {
102			Info("AddFile", "Add file %s as friend to %s",
103			dummy->GetName(), msg.Data());
104			}
105			}
106			delete arr;
107	loizides	1.1
108	loizides	1.4	return kTRUE;
109	loizides	1.1	}
110
111	loizides	1.12	//--------------------------------------------------------------------------------------------------
112	loizides	1.1	void Analysis::AddFile(const char *pname, Int_t eventlist)
113			{
114	paus	1.7	// Add file name to the event list specified by eventlist. The lists are used to hold filenames of
115			// different types of events. In case you dont want friend trees, just give no eventlist argument
116			// (default 0).
117	loizides	1.1
118	loizides	1.4	MitAssert("AddFile", pname != 0);
119	loizides	1.1
120	loizides	1.4	TList *l = 0;
121			if (eventlist >= 0 && eventlist < fNFriends) {
122	loizides	1.1
123	loizides	1.4	l = dynamic_cast<TList*>(fList->At(eventlist));
124			if (!l) {
125			Fatal("AddFile", "Requested list %d not found!", eventlist);
126			return;
127			}
128	loizides	1.1
129	loizides	1.4	} else if (eventlist == fNFriends) {
130	loizides	1.1
131	loizides	1.4	l = new TList;
132			l->SetOwner();
133			fList->Add(l);
134			fNFriends++;
135
136			} else if (eventlist < 0 \|\| eventlist > fNFriends) {
137			Error("AddFile", "Specified list %d not in [0,%d]", eventlist, fNFriends);
138			return;
139			}
140	loizides	1.1
141	loizides	1.4	if(!IsValidName(pname)) return;
142	loizides	1.1
143	loizides	1.4	l->Add(new TObjString(pname));
144	loizides	1.1
145	loizides	1.4	MDB(kAnalysis, 2)
146			Info("AddFile", "Added %s to list of files.", pname);
147	loizides	1.1	}
148
149	loizides	1.12	//--------------------------------------------------------------------------------------------------
150	loizides	1.1	void Analysis::AddFile(const TObject *oname, Int_t eventlist)
151			{
152	paus	1.7	// Add file name to the event list specified by eventlist. The lists are used to hold filenames of
153			// different types of events. In case you dont want mixing, just give no eventlist argument
154			// (default 0).
155	loizides	1.1
156	loizides	1.4	MitAssert("AddFile", oname != 0);
157	loizides	1.1
158	loizides	1.4	return AddFile(oname->GetName(), eventlist);
159	loizides	1.1	}
160
161	loizides	1.5	//________________________________________________________________________
162			Bool_t Analysis::AddFiles(const char *pname, Int_t nmax)
163			{
164	paus	1.7	// Add files from text file with given name. If nmax>0, maximum nmax files will be added.
165	loizides	1.5
166			MitAssert("AddFiles", pname != 0);
167
168			ifstream in;
169			in.open(pname);
170			if (!in) {
171			Error("AddFiles", "Can not open file with name %s", pname);
172			return kFALSE;
173			}
174
175			Int_t fc = 0;
176			while (in) {
177			TString line;
178			line.ReadLine(in);
179			cout << line << endl;
180			if (!line.EndsWith(".root"))
181			continue;
182			cout << line << endl;
183
184			if (!AddFile(line)) {
185			Error("AddFiles", "Error adding file with name %s", line.Data());
186			return kFALSE;
187			}
188
189			++fc;
190			if(nmax>0 && fc>=nmax) {
191			Info("AddFiles", "Maximal number (%d) of files added", nmax);
192			break;
193			}
194			}
195
196			return kTRUE;
197			}
198
199	loizides	1.12	//--------------------------------------------------------------------------------------------------
200	paus	1.13	Bool_t Analysis::AddDataset(const Dataset *dataset)
201			{
202	loizides	1.14	// Add a full dataset to the analysis.
203
204	paus	1.13	Bool_t status = true;
205
206			for (UInt_t i=0; i<dataset->NFiles(); i++)
207			status = (status && AddFile(dataset->FileUrl(i)));
208
209			return status;
210			}
211
212			//--------------------------------------------------------------------------------------------------
213	loizides	1.1	void Analysis::AddList(TList *list, Int_t eventlist)
214			{
215	paus	1.7	// Add file name to the event list specified by eventlist. The lists are used to hold filenames of
216			// different types of events. In case you dont want mixing, just give no eventlist argument
217			// (default 0).
218	loizides	1.4
219			MitAssert("AddList", list != 0);
220
221			TIter next(list);
222			while (TObject *obj = next())
223			AddFile(obj->GetName(), eventlist);
224	loizides	1.1	}
225
226	loizides	1.12	//--------------------------------------------------------------------------------------------------
227	loizides	1.1	void Analysis::AddLoader(TAMVirtualLoader *l)
228			{
229	loizides	1.4	// Add loader to the list of loaders.
230	loizides	1.1
231	loizides	1.4	fLoaders->Add(l);
232	loizides	1.1	}
233
234	loizides	1.12	//--------------------------------------------------------------------------------------------------
235	loizides	1.1	void Analysis::AddPackage(const char* name)
236			{
237	loizides	1.4	// Add package to the list of uploaded packages.
238	loizides	1.1
239	loizides	1.4	MitAssert("AddPackage", name != 0);
240			fPackages->Add(new TObjString(name));
241	loizides	1.1	}
242
243	loizides	1.12	//--------------------------------------------------------------------------------------------------
244	loizides	1.1	void Analysis::AddPackages(TList *list)
245			{
246	loizides	1.4	// Add list of packages to the list of uploaded packages.
247	loizides	1.1
248	loizides	1.4	MitAssert("AddPackage", list != 0);
249	loizides	1.1
250	loizides	1.4	TIter next(list);
251			while (TObject *obj = next()) {
252			fPackages->Add(new TObjString(obj->GetName()));
253			}
254	loizides	1.1	}
255
256	loizides	1.12	//--------------------------------------------------------------------------------------------------
257	loizides	1.1	Bool_t Analysis::Init()
258			{
259	paus	1.7	// Setup the TDSet and TChain to be used for the analysis with or without PROOF. If more than one
260			// list of file names was given, friend trees are supported.
261	loizides	1.4
262			if (fState == kRun \|\| fState == kInit) {
263			Error("Init", "Init in state %d is not possible! Call Terminate() first.",
264			Int_t(fState));
265			return kFALSE;
266			}
267
268			if (fNFriends <= 0) {
269			Error("Init", "List of friend lists is empty!");
270			return kFALSE;
271			}
272
273			if (!fSuperMod) {
274			Error("Init", "Top-level TAM module is NULL!");
275			return kFALSE;
276			}
277
278			if (fUseProof) { // first init our PROOF session
279			if (!InitProof()) return kFALSE;
280			}
281
282			// we do this here instead in Terminate() so that
283			// we can browse the output even after Terminate()
284			delete fSelector;
285			fSelector = 0;
286
287			fChain = new TChain(fTreeName);
288			fSet = new TDSet("TTree",fTreeName);
289
290			for(Int_t i=0; i<fNFriends; i++){
291
292			TList l = dynamic_cast<TList>(fList->At(i));
293			if (!l) {
294			Fatal("Init", "List %d not found!", i);
295	loizides	1.1	return kFALSE;
296	loizides	1.4	}
297
298			if (i == 0) {
299			TIter next(l);
300			while ( TObjString obj = dynamic_cast<TObjString>(next()) ) {
301			fChain->Add(obj->GetName());
302			fSet->Add(obj->GetName());
303			}
304	loizides	1.1
305	loizides	1.4	} else {
306	loizides	1.1
307	loizides	1.4	TChain *chain = new TChain(fTreeName);
308			TDSet *set = new TDSet("TTree",fTreeName);
309	loizides	1.1
310	loizides	1.4	TIter next(l);
311			while (TObjString obj = dynamic_cast<TObjString>(next())) {
312			chain->Add(obj->GetName());
313			set->Add(obj->GetName());
314	loizides	1.1	}
315
316	loizides	1.4	TString alias("TAMTREE_"); // aliases currently not used
317			alias+=i;
318	loizides	1.1
319	loizides	1.4	fChain->AddFriend(chain,alias.Data());
320			fSet->AddFriend(set,alias.Data());
321	loizides	1.1
322	loizides	1.4	fDeleteList->Add(chain);
323			fDeleteList->Add(set);
324			}
325	loizides	1.1
326	loizides	1.4	}
327	loizides	1.1
328	loizides	1.11	// create our customized loader plugin for TAM
329			TreeLoader *bl = new TreeLoader;
330			fLoaders->Add(bl);
331			fDeleteList->Add(bl);
332	loizides	1.1
333	loizides	1.15	// create our HLT framework module
334			HLTFwkMod *hltmod = 0;
335			if (fUseHLT) {
336			hltmod = new HLTFwkMod;
337			fDeleteList->Add(hltmod);
338			}
339
340	loizides	1.4	if (fUseProof) {
341	loizides	1.1
342	loizides	1.15	if (hltmod)
343			fProof->AddInput(hltmod);
344
345	loizides	1.4	fProof->AddInput(fSuperMod);
346			fLoaders->SetName("TAM_LOADERS");
347			fProof->AddInput(fLoaders);
348	loizides	1.1
349	loizides	1.4	} else {
350	loizides	1.1
351	loizides	1.4	// when not running Proof, we must make a selector
352	loizides	1.9	fSelector = new Selector;
353	loizides	1.16	fSelector->SetDoProxy(fDoProxy);
354	loizides	1.15	if (hltmod)
355			fSelector->AddInput(hltmod);
356	loizides	1.4	fSelector->AddInput(fSuperMod);
357			MDB(kAnalysis, 2)
358			fSelector->SetVerbosity(1);
359	loizides	1.1
360	loizides	1.4	// pass loaders to selector
361			TIter next(fLoaders);
362			while ( TAMVirtualLoader l = dynamic_cast<TAMVirtualLoader>(next()) )
363			fSelector->AddLoader(l);
364			}
365	loizides	1.1
366	loizides	1.4	fState = kInit;
367			return kTRUE;
368	loizides	1.1	}
369
370	loizides	1.12	//--------------------------------------------------------------------------------------------------
371	loizides	1.1	Bool_t Analysis::InitProof()
372			{
373	loizides	1.4	// Initialize PROOF connection.
374	loizides	1.1
375	loizides	1.4	if(fProof && fProof->IsValid())
376			return kTRUE;
377	loizides	1.1
378	loizides	1.4	delete fProof;
379	loizides	1.1
380	loizides	1.4	if (fMaster.Contains("rcf.bnl.gov")) {
381			for(Int_t i=0;i<5;i++) {
382			Warning("InitProof", "* DID YOU RUN PROOF_KINIT? %d (5) *", i);
383			gSystem->Sleep(1000);
384			}
385			}
386
387			MDB(kAnalysis, 1)
388			Info("InitProof", "Starting PROOF on master %s with config %s",
389			fMaster.Data(), fConfig.Data());
390
391			fProof = dynamic_cast<TProof*>(TProof::Open(fMaster, fConfig));
392			if (!fProof) {
393			Error("InitProof", "Could not start PROOF!");
394			return kFALSE;
395			}
396
397			MDB(kAnalysis, 3)
398			gROOT->Print();
399
400			//fProof->AddInput(new TNamed("PROOF_NewPacketizer",""));
401
402			Bool_t ret=kTRUE;
403			if (fPackages) {
404			// tell Proof what additional libraries we will need on each worker computer
405			ret = UploadPackages(fPackages);
406			}
407	loizides	1.1
408	loizides	1.4	return ret;
409	loizides	1.1	}
410
411	loizides	1.12	//--------------------------------------------------------------------------------------------------
412	loizides	1.1	void Analysis::Run()
413			{
414	loizides	1.4	// Run the analysis on the created file set.
415	loizides	1.1
416	loizides	1.4	if (fState == kPristine \|\| fState == kRun) {
417			Error("Run", "Run in state %d is not possible! Call Init() first.",
418			Int_t(fState));
419			}
420	loizides	1.1
421	loizides	1.4	if (fUseProof) {
422	loizides	1.1
423	loizides	1.4	MDB(kAnalysis, 1)
424			Info("Run", "Start processing with PROOF...");
425	loizides	1.1
426	loizides	1.9	fSet->Process("Selector","",fDoNEvents);
427	loizides	1.1
428	loizides	1.4	} else {
429	loizides	1.1
430	loizides	1.4	MDB(kAnalysis, 1)
431			Info("Run", "Start processing (no PROOF)...");
432	loizides	1.1
433	loizides	1.5	fChain->Process(fSelector,"",fDoNEvents);
434	loizides	1.4	}
435	loizides	1.1
436	loizides	1.4	MDB(kAnalysis, 1)
437			Info("Run", "Processing complete!");
438	loizides	1.1
439	loizides	1.4	fState = kRun;
440	loizides	1.1	}
441
442	loizides	1.12	//--------------------------------------------------------------------------------------------------
443	loizides	1.4	Bool_t Analysis::Run(Bool_t browse)
444	loizides	1.1	{
445	loizides	1.4	// Execute analysis and open TBrowser if requested.
446	loizides	1.1
447	loizides	1.4	if (Init()) {
448			Run();
449			Terminate();
450	paus	1.7	if (browse) {
451	loizides	1.4	new TBrowser;
452			}
453			return kTRUE;
454			}
455	loizides	1.1
456	loizides	1.4	Error("Execute", "Could not initialize analysis.");
457			return kFALSE;
458			}
459	loizides	1.1
460	loizides	1.12	//--------------------------------------------------------------------------------------------------
461	loizides	1.4	void Analysis::Terminate()
462			{
463			// Terminate current analysis run.
464	loizides	1.1
465	loizides	1.4	if (fState == kPristine \|\| fState == kTerminate) {
466			Error("Terminate", "Terminate in state %d is not possible! Call Init() first.",
467			Int_t(fState));
468			return;
469			}
470
471			if (fState == kRun) {
472
473			if (fUseProof) {
474			// the output list from Proof can (in principal) contain other objects
475			// besides the module output hierarchy.
476			TList* outputlist = fProof->GetOutputList();
477			TIter nextOut(outputlist);
478			while (TObject *obj = nextOut()) {
479			if (obj->InheritsFrom(TAMOutput::Class())) {
480			fOutput = dynamic_cast<TList*>(obj);
481			break;
482			}
483			}
484
485			} else {
486			fOutput = fSelector->GetModOutput();
487			}
488
489			if (fOutput && !fAnaOutput.IsNull()) {
490			TDirectory::TContext context(0); // automatically restore gDirectory
491
492			std::auto_ptr<TFile> outf(TFile::Open(fAnaOutput,"recreate","", fCompLevel));
493			if (outf.get() == 0) {
494			Error("Terminate", "Could not open file %s for output!", fAnaOutput.Data());
495	loizides	1.1	} else {
496	loizides	1.4	MDB(kAnalysis, 1)
497			Info("Terminate", "Saving output to %s!", fAnaOutput.Data());
498	loizides	1.1
499	loizides	1.16	if (fHierarchy)
500	loizides	1.4	fOutput->Write(fOutput->GetName(),TObject::kSingleKey);
501			else
502			fOutput->Write();
503	loizides	1.1
504			}
505	loizides	1.4	}
506			}
507	loizides	1.1
508	loizides	1.4	delete fChain;
509			delete fSet;
510			fDeleteList->Delete();
511	loizides	1.1	}
512
513	loizides	1.12	//--------------------------------------------------------------------------------------------------
514	loizides	1.1	Bool_t Analysis::UploadPackages(TList *packages)
515			{
516	loizides	1.4	// Upload list of par files to the server.
517	loizides	1.1
518	loizides	1.4	MitAssert("UploadPackages", packages != 0);
519	loizides	1.1
520	paus	1.7	for (Int_t i=0; i<packages->GetEntries(); i++) {
521	loizides	1.1
522	loizides	1.4	TObject* objstr = packages->At(i);
523	paus	1.7	if (!objstr) {
524	loizides	1.4	Error("InitProof", "Problem at package number %d!", i);
525			return kFALSE;
526			}
527	loizides	1.1
528	loizides	1.4	TString packname = objstr->GetName();
529	paus	1.7	Int_t en = 0;
530	loizides	1.4	if (packname.EndsWith("+")) {
531			en=1;
532			packname.Resize(packname.Length()-1);
533			}
534
535			ifstream ftest(gSystem->ExpandPathName(packname.Data()),ios_base::binary);
536	paus	1.7	if (!ftest.good()) {
537	loizides	1.4	Error("InitProof", "Could not open %s for upload!", packname.Data());
538			return kFALSE;
539			}
540	loizides	1.1
541	paus	1.7	if (fProof->UploadPackage(packname)<0) {
542	loizides	1.4	Error("UploadPackage", "Upload for %s failed!", packname.Data());
543			return kFALSE;
544			}
545	loizides	1.1
546	loizides	1.4	if (en == 1) {
547			Int_t pos=packname.Last('/')+1;
548	paus	1.7	if (pos)
549			packname.Remove(0,pos);
550			if (fProof->EnablePackage(packname)<0) {
551	loizides	1.4	Error("UploadPackage", "Enabling for %s failed!", packname.Data());
552			return kFALSE;
553	loizides	1.1	}
554	loizides	1.4	}
555			}
556	loizides	1.1
557	loizides	1.4	return kTRUE;
558	loizides	1.1	}