#include <TMethodCall.h>
#include <TClass.h>
+#include <TSystem.h>
+#include <TFile.h>
#include <TTree.h>
+#include <TH1.h>
#include <TROOT.h>
+#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
#include "AliAnalysisDataSlot.h"
#include "AliAnalysisTask.h"
+using std::endl;
+using std::cout;
+using std::ios;
+using std::setiosflags;
+using std::setprecision;
ClassImp(AliAnalysisDataContainer)
//______________________________________________________________________________
fDataReady(kFALSE),
fOwnedData(kFALSE),
fFileName(),
+ fFolderName(),
+ fFile(NULL),
fData(NULL),
fType(NULL),
fProducer(NULL),
fConsumers(NULL)
{
// Dummy ctor.
- TObject::SetBit(kContEvtByEvt, kTRUE);
}
//______________________________________________________________________________
AliAnalysisDataContainer::AliAnalysisDataContainer(const char *name, TClass *type)
:TNamed(name,""),
fDataReady(kFALSE),
- fOwnedData(kTRUE),
+ fOwnedData(kFALSE),
fFileName(),
+ fFolderName(),
+ fFile(NULL),
fData(NULL),
fType(type),
fProducer(NULL),
{
// Default constructor.
SetTitle(fType->GetName());
- TObject::SetBit(kContEvtByEvt, kTRUE);
}
//______________________________________________________________________________
fDataReady(cont.fDataReady),
fOwnedData(kFALSE),
fFileName(cont.fFileName),
+ fFolderName(cont.fFolderName),
+ fFile(NULL),
fData(cont.fData),
fType(NULL),
fProducer(cont.fProducer),
if (&cont != this) {
TNamed::operator=(cont);
fDataReady = cont.fDataReady;
- fOwnedData = kFALSE; // !!! Data owned by cont.
+ fOwnedData = kFALSE;
fFileName = cont.fFileName;
+ fFolderName = cont.fFolderName;
+ fFile = NULL;
fData = cont.fData;
GetType();
fProducer = cont.fProducer;
opt.ToLower();
Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
if (!dep) {
- printf("%sContainer: %s type: %s", ind.Data(), GetName(), GetTitle());
+ printf("%sContainer: %s type: %s POST_LOOP=%i", ind.Data(), GetName(), GetTitle(), IsPostEventLoop());
if (fProducer)
printf("%s = Data producer: task %s",ind.Data(),fProducer->GetName());
else
if (!fConsumers || !fConsumers->GetEntriesFast()) printf("-none-\n");
else printf("\n");
}
- printf("Filename: %s\n", fFileName.Data());
+ if (fFolderName.Length())
+ printf("Filename: %s folder: %s\n", fFileName.Data(), fFolderName.Data());
+ else
+ printf("Filename: %s\n", fFileName.Data());
TIter next(fConsumers);
AliAnalysisTask *task;
while ((task=(AliAnalysisTask*)next())) task->PrintTask(option, indent+3);
}
return kTRUE;
} else {
- cout<<"Data for container "<<GetName()<<" can be published only by producer task "<<fProducer->GetName()<<endl;
- //AliWarning(Form("Data for container %s can be published only by producer task %s", GetName(), fProducer->GetName()));
- return kFALSE;
+ // Ignore data posting from other than the producer
+// cout<<"Data for container "<<GetName()<<" can be published only by producer task "<<fProducer->GetName()<<endl;
+ //AliWarning(Form("Data for container %s can be published only by producer task %s", GetName(), fProducer->GetName()));
+ return kFALSE;
}
}
+//______________________________________________________________________________
+void AliAnalysisDataContainer::SetFileName(const char *filename)
+{
+// The filename field can be actually composed by the actual file name followed
+// by :dirname (optional):
+// filename = file_name[:dirname]
+// No slashes (/) allowed
+ fFileName = filename;
+ fFolderName = "";
+ Int_t index = fFileName.Index(":");
+ // Fill the folder name
+ if (index >= 0) {
+ fFolderName = fFileName(index+1, fFileName.Length()-index);
+ fFileName.Remove(index);
+ }
+ if (!fFileName.Length())
+ Fatal("SetFileName", "Empty file name");
+ if (fFileName.Index("/")>=0)
+ Fatal("SetFileName", "No slashes (/) allowed in the file name");
+}
+
//______________________________________________________________________________
void AliAnalysisDataContainer::SetProducer(AliAnalysisTask *prod, Int_t islot)
{
{
// Wraps data for sending it through the net.
AliAnalysisDataWrapper *pack = 0;
- if (!fData) return pack;
+ if (!fData) {
+ Error("ExportData", "Container %s - No data to be wrapped !", GetName());
+ return pack;
+ }
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (mgr && mgr->GetDebugLevel() > 1) printf(" ExportData: Wrapping data %s for container %s\n", fData->GetName(),GetName());
pack = new AliAnalysisDataWrapper(fData);
pack->SetName(fName.Data());
return pack;
// Unwraps data from a data wrapper.
if (pack) {
fData = pack->Data();
+ if (!fData) {
+ Error("ImportData", "No data was wrapped for container %s", GetName());
+ return;
+ }
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (mgr && mgr->GetDebugLevel() > 1) printf(" ImportData: Unwrapping data %s for container %s\n", fData->GetName(),GetName());
fDataReady = kTRUE;
+ // Imported wrappers do not own data anymore (AG 13-11-07)
+ pack->SetDeleteData(kFALSE);
}
}
ClassImp (AliAnalysisDataWrapper)
+//______________________________________________________________________________
+AliAnalysisDataWrapper::AliAnalysisDataWrapper(TObject *data)
+ :TNamed(),
+ fData(data)
+{
+// Ctor.
+ if (data) SetName(data->GetName());
+}
+
+//______________________________________________________________________________
+AliAnalysisDataWrapper::~AliAnalysisDataWrapper()
+{
+// Dtor.
+ if (fData && TObject::TestBit(kDeleteData)) delete fData;
+}
+
//______________________________________________________________________________
AliAnalysisDataWrapper &AliAnalysisDataWrapper::operator=(const AliAnalysisDataWrapper &other)
{
{
// Merge a list of containers with this one. Containers in the list must have
// data of the same type.
+ if (TH1::AddDirectoryStatus()) TH1::AddDirectory(kFALSE);
if (!fData) return 0;
if (!list || list->IsEmpty()) return 1;
- printf("Merging %d data wrappers %s\n", list->GetSize()+1, GetName());
+ SetDeleteData();
+
TMethodCall callEnv;
- if (fData->InheritsFrom(TSeqCollection::Class())) {
- TSeqCollection *coll = (TSeqCollection*)fData;
- if (coll->IsEmpty()) return 0;
- Int_t nentries = coll->GetEntries();
- AliAnalysisDataWrapper *top;
- TIter next(list);
- TSeqCollection *collcrt = 0;
- TList *list1 = 0;
- for (Int_t i=0; i<nentries; i++) {
- list1 = new TList();
- top = new AliAnalysisDataWrapper(coll->At(i));
- next.Reset();
- while ((collcrt=(TSeqCollection*)next()))
- list1->Add(new AliAnalysisDataWrapper(collcrt->At(i)));
- if (!top->Merge(list1)) {
- list1->Delete();
- delete list1;
- return 0;
- }
- list1->Delete();
- delete list1;
- }
- return nentries;
- }
-
if (fData->IsA())
callEnv.InitWithPrototype(fData->IsA(), "Merge", "TCollection*");
if (!callEnv.IsValid()) {
return 1;
}
- TIter next(list);
+ TIter next1(list);
AliAnalysisDataWrapper *cont;
// Make a list where to temporary store the data to be merged.
TList *collectionData = new TList();
Int_t count = 0; // object counter
- while ((cont=(AliAnalysisDataWrapper*)next())) {
+ // printf("Wrapper %s 0x%lx (data=%s) merged with:\n", GetName(), (ULong_t)this, fData->ClassName());
+ while ((cont=(AliAnalysisDataWrapper*)next1())) {
+ cont->SetDeleteData();
TObject *data = cont->Data();
if (!data) continue;
- if (strcmp(cont->GetName(), GetName())) continue;
+ // printf(" - %s 0x%lx (data=%s)\n", cont->GetName(), (ULong_t)cont, data->ClassName());
collectionData->Add(data);
count++;
}
return count+1;
}
+
+ClassImp(AliAnalysisFileDescriptor)
+
+//______________________________________________________________________________
+AliAnalysisFileDescriptor::AliAnalysisFileDescriptor()
+ :TObject(), fLfn(), fGUID(), fUrl(), fPfn(), fSE(),
+ fIsArchive(kFALSE), fImage(0), fNreplicas(0),
+ fStartBytes(0), fReadBytes(0), fSize(0), fOpenedAt(0),
+ fOpenTime(0.), fProcessingTime(0.), fThroughput(0.), fTimer()
+{
+// I/O constructor
+}
+
+//______________________________________________________________________________
+AliAnalysisFileDescriptor::AliAnalysisFileDescriptor(const TFile *file)
+ :TObject(), fLfn(), fGUID(), fUrl(), fPfn(), fSE(),
+ fIsArchive(kFALSE), fImage(0), fNreplicas(0),
+ fStartBytes(0), fReadBytes(0), fSize(0), fOpenedAt(0),
+ fOpenTime(0.), fProcessingTime(0.), fThroughput(0.), fTimer()
+{
+// Normal constructor
+ if (file->InheritsFrom("TAlienFile")) {
+ fLfn =(const char*)gROOT->ProcessLine(Form("((TAlienFile*)%p)->GetLfn();", file));
+ fGUID =(const char*)gROOT->ProcessLine(Form("((TAlienFile*)%p)->GetGUID();", file));
+ fUrl =(const char*)gROOT->ProcessLine(Form("((TAlienFile*)%p)->GetUrl();", file));
+ fPfn =(const char*)gROOT->ProcessLine(Form("((TAlienFile*)%p)->GetPfn();", file));
+ fSE = (const char*)gROOT->ProcessLine(Form("((TAlienFile*)%p)->GetSE();", file));
+ fImage = (Int_t)gROOT->ProcessLine(Form("((TAlienFile*)%p)->GetImage();", file));
+ fNreplicas = (Int_t)gROOT->ProcessLine(Form("((TAlienFile*)%p)->GetNreplicas();", file));
+ fOpenedAt = gROOT->ProcessLine(Form("((TAlienFile*)%p)->GetOpenTime();", file));
+ gROOT->ProcessLine(Form("((AliAnalysisFileDescriptor*)%p)->SetOpenTime(((TAlienFile*)%p)->GetElapsed());", this, file));
+ } else {
+ fLfn = file->GetName();
+ fPfn = file->GetName();
+ fUrl = file->GetName();
+ fSE = "local";
+ if (!fPfn.BeginsWith("/")) fPfn.Prepend(Form("%s/",gSystem->WorkingDirectory()));
+ fOpenedAt = time(0);
+ }
+ fStartBytes = TFile::GetFileBytesRead();
+ fIsArchive = file->IsArchive();
+ fSize = file->GetSize();
+}
+
+//______________________________________________________________________________
+AliAnalysisFileDescriptor::AliAnalysisFileDescriptor(const AliAnalysisFileDescriptor &other)
+ :TObject(other), fLfn(other.fLfn), fGUID(other.fGUID),
+ fUrl(other.fUrl), fPfn(other.fPfn), fSE(other.fSE),
+ fIsArchive(other.fIsArchive), fImage(other.fImage),
+ fNreplicas(other.fNreplicas), fStartBytes(other.fStartBytes), fReadBytes(other.fReadBytes),
+ fSize(other.fSize), fOpenedAt(other.fOpenedAt), fOpenTime(other.fOpenTime),
+ fProcessingTime(other.fProcessingTime), fThroughput(other.fThroughput), fTimer()
+{
+// CC
+}
+
+//______________________________________________________________________________
+AliAnalysisFileDescriptor &AliAnalysisFileDescriptor::operator=(const AliAnalysisFileDescriptor &other)
+{
+// Assignment.
+ if (&other == this) return *this;
+ TObject::operator=(other);
+ fLfn = other.fLfn;
+ fGUID = other.fGUID;
+ fUrl = other.fUrl;
+ fPfn = other.fPfn;
+ fSE = other.fSE;
+ fIsArchive = other.fIsArchive;
+ fImage = other.fImage;
+ fNreplicas = other.fNreplicas;
+ fStartBytes = other.fStartBytes;;
+ fReadBytes = other.fReadBytes;
+ fSize = other.fSize;
+ fOpenedAt = other.fOpenedAt;
+ fOpenTime = other.fOpenTime;
+ fProcessingTime = other.fProcessingTime;
+ fThroughput = other.fThroughput;
+ return *this;
+}
+
+//______________________________________________________________________________
+AliAnalysisFileDescriptor::~AliAnalysisFileDescriptor()
+{
+// Destructor
+}
+
+//______________________________________________________________________________
+void AliAnalysisFileDescriptor::Done()
+{
+// Must be called at the end of processing, providing file->GetBytesRead() as argument.
+ fTimer.Stop();
+ const Double_t megabyte = 1048576.;
+// Long64_t stampnow = time(0);
+ fReadBytes = TFile::GetFileBytesRead()-fStartBytes;
+// fProcessingTime = stampnow-fOpenedAt;
+ fProcessingTime = fTimer.RealTime();
+ Double_t readsize = fReadBytes/megabyte;
+ fThroughput = readsize/fProcessingTime;
+}
+
+//______________________________________________________________________________
+void AliAnalysisFileDescriptor::Print(Option_t*) const
+{
+// Print info about the file descriptor
+ const Double_t megabyte = 1048576.;
+ printf("===== Logical file name: %s =====\n", fLfn.Data());
+ printf(" Pfn: %s\n", fPfn.Data());
+ printf(" url: %s\n", fUrl.Data());
+ printf(" access time: %lld from SE: %s image %d/%d\n", fOpenedAt, fSE.Data(), fImage, fNreplicas);
+ printf(" open time: %g [sec]\n", fOpenTime);
+ printf(" file size: %g [MB], read size: %g [MB]\n", fSize/megabyte, fReadBytes/megabyte);
+ printf(" processing time [sec]: %g\n", fProcessingTime);
+ printf(" average throughput: %g [MB/sec]\n", fThroughput);
+}
+
+//______________________________________________________________________________
+void AliAnalysisFileDescriptor::SavePrimitive(std::ostream &out, Option_t *)
+{
+// Stream info to file
+ const Double_t megabyte = 1048576.;
+ out << "#################################################################" << endl;
+ out << "pfn " << fPfn.Data() << endl;
+ out << "url " << fUrl.Data() << endl;
+ out << "se " << fSE.Data() << endl;
+ out << "image " << fImage << endl;
+ out << "nreplicas " << fNreplicas << endl;
+ out << "openstamp " << fOpenedAt << endl;
+ out << setiosflags(std::ios::fixed) << std::setprecision(3);
+ out << "opentime " << fOpenTime << endl;
+ out << "runtime " << fProcessingTime << endl;
+ out << "filesize " << fSize/megabyte << endl;
+ out << "readsize " << fReadBytes/megabyte << endl;
+ out << "throughput " << fThroughput << endl;
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff