// This TTask is normally called from Reconstructioner, but can as well be used in
// standalone mode.
// Use Case:
-// root [0] AliPHOSClusterizerv1 * cl = new AliPHOSClusterizerv1("galice.root")
+// root [0] AliPHOSClusterizerv1 * cl = new AliPHOSClusterizerv1("galice.root", "recpointsname", "digitsname")
// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
-// //reads gAlice from header file "..."
+// // reads gAlice from header file "galice.root", uses digits stored in the branch names "digitsname" (default = "Default")
+// // and saves recpoints in branch named "recpointsname" (default = "digitsname")
// root [1] cl->ExecuteTask()
// //finds RecPoints in all events stored in galice.root
// root [2] cl->SetDigitsBranch("digits2")
{
// default ctor (to be used mainly by Streamer)
- fNumberOfCpvClusters = 0 ;
- fNumberOfEmcClusters = 0 ;
-
- fCpvClusteringThreshold = 0.0;
- fEmcClusteringThreshold = 0.2;
-
- fEmcLocMaxCut = 0.03 ;
- fCpvLocMaxCut = 0.03 ;
-
- fW0 = 4.5 ;
- fW0CPV = 4.0 ;
-
- fEmcTimeGate = 1.e-8 ;
-
- fToUnfold = kTRUE ;
-
- fHeaderFileName = "" ;
- fDigitsBranchTitle = "" ;
- fRecPointsInRun = 0 ;
+ InitParameters() ;
+ fDefaultInit = kTRUE ;
}
//____________________________________________________________________________
-AliPHOSClusterizerv1::AliPHOSClusterizerv1(const char* headerFile,const char* name)
-:AliPHOSClusterizer(headerFile, name)
+AliPHOSClusterizerv1::AliPHOSClusterizerv1(const char* headerFile,const char* name, const Bool_t toSplit)
+:AliPHOSClusterizer(headerFile, name, toSplit)
{
// ctor with the indication of the file where header Tree and digits Tree are stored
-
- fNumberOfCpvClusters = 0 ;
- fNumberOfEmcClusters = 0 ;
+ InitParameters() ;
- fCpvClusteringThreshold = 0.0;
- fEmcClusteringThreshold = 0.2;
-
- fEmcLocMaxCut = 0.03 ;
- fCpvLocMaxCut = 0.03 ;
-
- fW0 = 4.5 ;
- fW0CPV = 4.0 ;
-
- fEmcTimeGate = 1.e-8 ;
-
- fToUnfold = kTRUE ;
-
- fHeaderFileName = GetTitle() ;
- fDigitsBranchTitle = GetName() ;
-
- TString clusterizerName( GetName()) ;
- clusterizerName.Append(":") ;
- clusterizerName.Append(Version()) ;
- SetName(clusterizerName) ;
- fRecPointsInRun = 0 ;
-
Init() ;
+ fDefaultInit = kFALSE ;
}
+
//____________________________________________________________________________
AliPHOSClusterizerv1::~AliPHOSClusterizerv1()
{
+ // dtor
+
+
+// if (!fDefaultInit) {
+// AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
+
+// // remove the task from the folder list
+// gime->RemoveTask("C",GetName()) ;
+
+// // remove the data from the folder list
+// TString name(GetName()) ;
+// name.Remove(name.Index(":")) ;
+// gime->RemoveObjects("D", name) ; // Digits
+// gime->RemoveObjects("RE", name) ; // EMCARecPoints
+// gime->RemoveObjects("RC", name) ; // CPVRecPoints
+
+// // Delete gAlice
+// gime->CloseFile() ;
+
+ fSplitFile = 0 ;
+// }
}
+
+//____________________________________________________________________________
+const TString AliPHOSClusterizerv1::BranchName() const
+{
+ TString branchName(GetName() ) ;
+ branchName.Remove(branchName.Index(Version())-1) ;
+ return branchName ;
+}
+
//____________________________________________________________________________
Float_t AliPHOSClusterizerv1::Calibrate(Int_t amp, Int_t absId) const
-{
+{ //To be replased later by the method, reading individual parameters from the database
if(absId <= fEmcCrystals) //calibrate as EMC
return fADCpedestalEmc + amp*fADCchanelEmc ;
else //Digitize as CPV
if(strstr(option,"print"))
Print("") ;
- gAlice->GetEvent(0) ;
+// gAlice->GetEvent(0) ;
- //check, if the branch with name of this" already exits?
- TObjArray * lob = (TObjArray*)gAlice->TreeR()->GetListOfBranches() ;
- TIter next(lob) ;
- TBranch * branch = 0 ;
- Bool_t phosemcfound = kFALSE, phoscpvfound = kFALSE, clusterizerfound = kFALSE ;
-
- TString branchname = GetName() ;
- branchname.Remove(branchname.Index(Version())-1) ;
-
- while ( (branch = (TBranch*)next()) && (!phosemcfound || !phoscpvfound || !clusterizerfound) ) {
- if ( (strcmp(branch->GetName(), "PHOSEmcRP")==0) && (strcmp(branch->GetTitle(), branchname.Data())==0) )
- phosemcfound = kTRUE ;
+// //check, if the branch with name of this" already exits?
+// if(gAlice->TreeR()) {
+// TObjArray * lob = (TObjArray*)gAlice->TreeR()->GetListOfBranches() ;
+// TIter next(lob) ;
+// TBranch * branch = 0 ;
+// Bool_t phosemcfound = kFALSE, phoscpvfound = kFALSE, clusterizerfound = kFALSE ;
- else if ( (strcmp(branch->GetName(), "PHOSCpvRP")==0) && (strcmp(branch->GetTitle(), branchname.Data())==0) )
- phoscpvfound = kTRUE ;
-
- else if ((strcmp(branch->GetName(), "AliPHOSClusterizer")==0) && (strcmp(branch->GetTitle(), GetName())==0) )
- clusterizerfound = kTRUE ;
- }
-
- if ( phoscpvfound || phosemcfound || clusterizerfound ) {
- cerr << "WARNING: AliPHOSClusterizer::Exec -> Emc(Cpv)RecPoints and/or Clusterizer branch with name "
- << branchname.Data() << " already exits" << endl ;
- return ;
- }
-
+// TString branchname = GetName() ;
+// branchname.Remove(branchname.Index(Version())-1) ;
+
+// while ( (branch = (TBranch*)next()) && (!phosemcfound || !phoscpvfound || !clusterizerfound) ) {
+// if ( (strcmp(branch->GetName(), "PHOSEmcRP")==0) && (strcmp(branch->GetTitle(), branchname.Data())==0) )
+// phosemcfound = kTRUE ;
+
+// else if ( (strcmp(branch->GetName(), "PHOSCpvRP")==0) && (strcmp(branch->GetTitle(), branchname.Data())==0) )
+// phoscpvfound = kTRUE ;
+
+// else if ((strcmp(branch->GetName(), "AliPHOSClusterizer")==0) && (strcmp(branch->GetTitle(), GetName())==0) )
+// clusterizerfound = kTRUE ;
+// }
+
+// if ( phoscpvfound || phosemcfound || clusterizerfound ) {
+// cerr << "WARNING: AliPHOSClusterizer::Exec -> Emc(Cpv)RecPoints and/or Clusterizer branch with name "
+// << branchname.Data() << " already exits" << endl ;
+// return ;
+// }
+// }
+
AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
- Int_t nevents = (Int_t) gAlice->TreeE()->GetEntries() ;
+ if(gime->BranchExists("RecPoints"))
+ return ;
+ Int_t nevents = gime->MaxEvent() ;
Int_t ievent ;
-
+
for(ievent = 0; ievent < nevents; ievent++){
-
- if(ievent == 0) GetCalibrationParameters() ;
-
+
+ gime->Event(ievent,"D") ;
+
+ if(ievent == 0)
+ GetCalibrationParameters() ;
+
fNumberOfEmcClusters = 0 ;
fNumberOfCpvClusters = 0 ;
-
- gime->Event(ievent,"D") ;
+
// if(!ReadDigits(ievent)) continue; //reads digits for event ievent
MakeClusters() ;
- if(fToUnfold) MakeUnfolding() ;
+ if(fToUnfold)
+ MakeUnfolding() ;
WriteRecPoints(ievent) ;
- if(strstr(option,"deb")) PrintRecPoints(option) ;
- }
+ if(strstr(option,"deb"))
+ PrintRecPoints(option) ;
+
+ //increment the total number of digits per run
+ fRecPointsInRun += gime->EmcRecPoints()->GetEntriesFast() ;
+ fRecPointsInRun += gime->CpvRecPoints()->GetEntriesFast() ;
+ }
if(strstr(option,"tim")){
gBenchmark->Stop("PHOSClusterizer");
}
//____________________________________________________________________________
-Bool_t AliPHOSClusterizerv1::FindFit(AliPHOSEmcRecPoint * emcRP, int * maxAt, Float_t * maxAtEnergy,
+Bool_t AliPHOSClusterizerv1::FindFit(AliPHOSEmcRecPoint * emcRP, AliPHOSDigit ** maxAt, Float_t * maxAtEnergy,
Int_t nPar, Float_t * fitparameters) const
{
// Calls TMinuit to fit the energy distribution of a cluster with several maxima
const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
for(iDigit = 0; iDigit < nDigits; iDigit++){
- digit = (AliPHOSDigit *) maxAt[iDigit];
+ digit = maxAt[iDigit];
Int_t relid[4] ;
Float_t x = 0.;
void AliPHOSClusterizerv1::GetCalibrationParameters()
{
AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
- TString branchname = GetName() ;
- branchname.Remove(branchname.Index(Version())-1) ;
- AliPHOSDigitizer * dig = gime->Digitizer(branchname) ;
+ const AliPHOSDigitizer * dig = gime->Digitizer(BranchName()) ;
+
fADCchanelEmc = dig->GetEMCchannel() ;
fADCpedestalEmc = dig->GetEMCpedestal();
-
+
fADCchanelCpv = dig->GetCPVchannel() ;
fADCpedestalCpv = dig->GetCPVpedestal() ;
-
+
}
//____________________________________________________________________________
void AliPHOSClusterizerv1::Init()
TString branchname = GetName() ;
branchname.Remove(branchname.Index(Version())-1) ;
- AliPHOSGetter * gime = AliPHOSGetter::GetInstance(GetTitle(), branchname) ;
+ AliPHOSGetter * gime = AliPHOSGetter::GetInstance(GetTitle(),branchname.Data(), fToSplit ) ;
if ( gime == 0 ) {
cerr << "ERROR: AliPHOSClusterizerv1::Init -> Could not obtain the Getter object !" << endl ;
return ;
}
+
+ fSplitFile = 0 ;
+ if(fToSplit){
+ // construct the name of the file as /path/EMCAL.SDigits.root
+ //First - extract full path if necessary
+ TString fileName(GetTitle()) ;
+ Ssiz_t islash = fileName.Last('/') ;
+ if(islash<fileName.Length())
+ fileName.Remove(islash+1,fileName.Length()) ;
+ else
+ fileName="" ;
+ // Next - append the file name
+ fileName+="PHOS.RecData." ;
+ if((strcmp(branchname.Data(),"Default")!=0)&&(strcmp(branchname.Data(),"")!=0)){
+ fileName+=branchname ;
+ fileName+="." ;
+ }
+ fileName+="root" ;
+ // Finally - check if the file already opened or open the file
+ fSplitFile = static_cast<TFile*>(gROOT->GetFile(fileName.Data()));
+ if(!fSplitFile)
+ fSplitFile = TFile::Open(fileName.Data(),"update") ;
+ }
+
+
const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
fEmcCrystals = geom->GetNModules() * geom->GetNCristalsInModule() ;
gMinuit = new TMinuit(100) ;
gime->PostClusterizer(this) ;
- // create a folder on the white board //YSAlice/WhiteBoard/RecPoints/PHOS/recpointsName
- gime->PostRecPoints(branchname ) ;
+ gime->PostRecPoints(branchname) ;
- gime->PostDigits(branchname) ;
- gime->PostDigitizer(branchname) ;
+ // gime->PostDigits() ;
+ // gime->PostDigitizer() ;
}
+//____________________________________________________________________________
+void AliPHOSClusterizerv1::InitParameters()
+{
+
+ fNumberOfCpvClusters = 0 ;
+ fNumberOfEmcClusters = 0 ;
+
+ fCpvClusteringThreshold = 0.0;
+ fEmcClusteringThreshold = 0.2;
+
+ fEmcLocMaxCut = 0.03 ;
+ fCpvLocMaxCut = 0.03 ;
+
+ fW0 = 4.5 ;
+ fW0CPV = 4.0 ;
+
+ fEmcTimeGate = 1.e-8 ;
+
+ fToUnfold = kTRUE ;
+
+ // fHeaderFileName = GetTitle() ;
+ // fDigitsBranchTitle = GetName() ;
+
+ TString clusterizerName( GetName()) ;
+ if (clusterizerName.IsNull() )
+ clusterizerName = "Default" ;
+ clusterizerName.Append(":") ;
+ clusterizerName.Append(Version()) ;
+ SetName(clusterizerName) ;
+ fRecPointsInRun = 0 ;
+
+}
+
//____________________________________________________________________________
Int_t AliPHOSClusterizerv1::AreNeighbours(AliPHOSDigit * d1, AliPHOSDigit * d2)const
{
Bool_t rv = kFALSE ;
const AliPHOSGeometry * geom = AliPHOSGetter::GetInstance()->PHOSGeometry() ;
- Int_t relid[4] ;
- geom->AbsToRelNumbering(digit->GetId(), relid) ;
+ Int_t nEMC = geom->GetNModules()*geom->GetNPhi()*geom->GetNZ();
- if ( relid[1] == 0 ) rv = kTRUE;
+ if(digit->GetId() <= nEMC ) rv = kTRUE;
return rv ;
}
Bool_t rv = kFALSE ;
const AliPHOSGeometry * geom = AliPHOSGetter::GetInstance()->PHOSGeometry() ;
- Int_t relid[4] ;
- geom->AbsToRelNumbering(digit->GetId(), relid) ;
+ Int_t nEMC = geom->GetNModules()*geom->GetNPhi()*geom->GetNZ();
- if ( relid[1] != 0 ) rv = kTRUE;
+ if(digit->GetId() > nEMC ) rv = kTRUE;
return rv ;
}
// Creates new branches with given title
// fills and writes into TreeR.
-
- TString branchName(GetName() ) ;
- branchName.Remove(branchName.Index(Version())-1) ;
-
+
+
AliPHOSGetter *gime = AliPHOSGetter::GetInstance() ;
- TObjArray * emcRecPoints = gime->EmcRecPoints(branchName) ;
- TObjArray * cpvRecPoints = gime->CpvRecPoints(branchName) ;
- TClonesArray * digits = gime->Digits(branchName) ;
+ TObjArray * emcRecPoints = gime->EmcRecPoints() ;
+ TObjArray * cpvRecPoints = gime->CpvRecPoints() ;
+ TClonesArray * digits = gime->Digits() ;
+ TTree * treeR ;
+
+ if(fToSplit){
+ if(!fSplitFile)
+ return ;
+ fSplitFile->cd() ;
+ TString name("TreeR") ;
+ name += event ;
+ treeR = dynamic_cast<TTree*>(fSplitFile->Get(name));
+ }
+ else{
+ treeR = gAlice->TreeR();
+ }
+
+ if(!treeR){
+ gAlice->MakeTree("R", fSplitFile);
+ treeR = gAlice->TreeR() ;
+ }
Int_t index ;
//Evaluate position, dispersion and other RecPoint properties...
for(index = 0; index < emcRecPoints->GetEntries(); index++)
((AliPHOSEmcRecPoint *)emcRecPoints->At(index))->EvalAll(fW0,digits) ;
-
+
emcRecPoints->Sort() ;
-
for(index = 0; index < emcRecPoints->GetEntries(); index++)
((AliPHOSEmcRecPoint *)emcRecPoints->At(index))->SetIndexInList(index) ;
-
+
emcRecPoints->Expand(emcRecPoints->GetEntriesFast()) ;
-
+
//Now the same for CPV
for(index = 0; index < cpvRecPoints->GetEntries(); index++)
((AliPHOSRecPoint *)cpvRecPoints->At(index))->EvalAll(fW0CPV,digits) ;
-
+
cpvRecPoints->Sort() ;
-
+
for(index = 0; index < cpvRecPoints->GetEntries(); index++)
((AliPHOSRecPoint *)cpvRecPoints->At(index))->SetIndexInList(index) ;
-
- cpvRecPoints->Expand(cpvRecPoints->GetEntriesFast()) ;
- //Make branches in TreeR for RecPoints and Clusterizer
- char * filename = 0;
- if(gSystem->Getenv("CONFIG_SPLIT_FILE")!=0){ //generating file name
- filename = new char[strlen(gAlice->GetBaseFile())+20] ;
- sprintf(filename,"%s/PHOS.Reco.root",gAlice->GetBaseFile()) ;
- }
-
- //Make new branches
- TDirectory *cwd = gDirectory;
+ cpvRecPoints->Expand(cpvRecPoints->GetEntriesFast()) ;
-
Int_t bufferSize = 32000 ;
Int_t splitlevel = 0 ;
-
+
//First EMC
- TBranch * emcBranch = gAlice->TreeR()->Branch("PHOSEmcRP","TObjArray",&emcRecPoints,bufferSize,splitlevel);
- emcBranch->SetTitle(branchName);
- if (filename) {
- emcBranch->SetFile(filename);
- TIter next( emcBranch->GetListOfBranches());
- TBranch * sb ;
- while ((sb=(TBranch*)next())) {
- sb->SetFile(filename);
- }
-
- cwd->cd();
- }
+ TBranch * emcBranch = treeR->Branch("PHOSEmcRP","TObjArray",&emcRecPoints,bufferSize,splitlevel);
+ emcBranch->SetTitle(BranchName());
//Now CPV branch
- TBranch * cpvBranch = gAlice->TreeR()->Branch("PHOSCpvRP","TObjArray",&cpvRecPoints,bufferSize,splitlevel);
- cpvBranch->SetTitle(branchName);
- if (filename) {
- cpvBranch->SetFile(filename);
- TIter next( cpvBranch->GetListOfBranches());
- TBranch * sb;
- while ((sb=(TBranch*)next())) {
- sb->SetFile(filename);
- }
- cwd->cd();
- }
+ TBranch * cpvBranch = treeR->Branch("PHOSCpvRP","TObjArray",&cpvRecPoints,bufferSize,splitlevel);
+ cpvBranch->SetTitle(BranchName());
//And Finally clusterizer branch
- AliPHOSClusterizerv1 * cl = (AliPHOSClusterizerv1*)gime->Clusterizer(branchName) ;
- TBranch * clusterizerBranch = gAlice->TreeR()->Branch("AliPHOSClusterizer","AliPHOSClusterizerv1",
+ AliPHOSClusterizerv1 * cl = this ;
+ TBranch * clusterizerBranch = treeR->Branch("AliPHOSClusterizer","AliPHOSClusterizerv1",
&cl,bufferSize,splitlevel);
- clusterizerBranch->SetTitle(branchName);
- if (filename) {
- clusterizerBranch->SetFile(filename);
- TIter next( clusterizerBranch->GetListOfBranches());
- TBranch * sb ;
- while ((sb=(TBranch*)next())) {
- sb->SetFile(filename);
- }
- cwd->cd();
- }
+ clusterizerBranch->SetTitle(BranchName());
+
emcBranch ->Fill() ;
cpvBranch ->Fill() ;
clusterizerBranch->Fill() ;
- gAlice->TreeR()->Write(0,kOverwrite) ;
-
+ treeR->AutoSave() ; //Write(0,kOverwrite) ;
+ if(gAlice->TreeR()!=treeR)
+ treeR->Delete();
}
//____________________________________________________________________________
{
// Steering method to construct the clusters stored in a list of Reconstructed Points
// A cluster is defined as a list of neighbour digits
- TString branchName(GetName()) ;
- branchName.Remove(branchName.Index(Version())-1) ;
AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
- TObjArray * emcRecPoints = gime->EmcRecPoints(branchName) ;
- TObjArray * cpvRecPoints = gime->CpvRecPoints(branchName) ;
+ TObjArray * emcRecPoints = gime->EmcRecPoints(BranchName()) ;
+ TObjArray * cpvRecPoints = gime->CpvRecPoints(BranchName()) ;
emcRecPoints->Delete() ;
cpvRecPoints->Delete() ;
- TClonesArray * digits = gime->Digits(branchName) ;
+ TClonesArray * digits = gime->Digits() ;
+ if ( !digits ) {
+ cerr << "ERROR: AliPHOSClusterizerv1::MakeClusters -> Digits with name "
+ << GetName() << " not found ! " << endl ;
+ abort() ;
+ }
TClonesArray * digitsC = (TClonesArray*)digits->Clone() ;
if(fNumberOfEmcClusters >= emcRecPoints->GetSize())
emcRecPoints->Expand(2*fNumberOfEmcClusters+1) ;
- emcRecPoints->AddAt(new AliPHOSEmcRecPoint(), fNumberOfEmcClusters) ;
+ emcRecPoints->AddAt(new AliPHOSEmcRecPoint(""), fNumberOfEmcClusters) ;
clu = (AliPHOSEmcRecPoint *) emcRecPoints->At(fNumberOfEmcClusters) ;
fNumberOfEmcClusters++ ;
clu->AddDigit(*digit, Calibrate(digit->GetAmp(),digit->GetId())) ;
if(fNumberOfCpvClusters >= cpvRecPoints->GetSize())
cpvRecPoints->Expand(2*fNumberOfCpvClusters+1);
- cpvRecPoints->AddAt(new AliPHOSCpvRecPoint(), fNumberOfCpvClusters) ;
+ cpvRecPoints->AddAt(new AliPHOSCpvRecPoint(""), fNumberOfCpvClusters) ;
clu = (AliPHOSCpvRecPoint *) cpvRecPoints->At(fNumberOfCpvClusters) ;
fNumberOfCpvClusters++ ;
AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
+
const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
- TObjArray * emcRecPoints = gime->EmcRecPoints() ;
- TObjArray * cpvRecPoints = gime->CpvRecPoints() ;
+ TObjArray * emcRecPoints = gime->EmcRecPoints(BranchName()) ;
+ TObjArray * cpvRecPoints = gime->CpvRecPoints(BranchName()) ;
TClonesArray * digits = gime->Digits() ;
// Unfold first EMC clusters
break ;
Int_t nMultipl = emcRecPoint->GetMultiplicity() ;
- Int_t * maxAt = new Int_t[nMultipl] ;
+ AliPHOSDigit ** maxAt = new AliPHOSDigit*[nMultipl] ;
Float_t * maxAtEnergy = new Float_t[nMultipl] ;
Int_t nMax = emcRecPoint->GetNumberOfLocalMax(maxAt, maxAtEnergy,fEmcLocMaxCut,digits) ;
AliPHOSEmcRecPoint * emcRecPoint = (AliPHOSEmcRecPoint*) recPoint ;
Int_t nMultipl = emcRecPoint->GetMultiplicity() ;
- Int_t * maxAt = new Int_t[nMultipl] ;
+ AliPHOSDigit ** maxAt = new AliPHOSDigit*[nMultipl] ;
Float_t * maxAtEnergy = new Float_t[nMultipl] ;
Int_t nMax = emcRecPoint->GetNumberOfLocalMax(maxAt, maxAtEnergy,fCpvLocMaxCut,digits) ;
//____________________________________________________________________________
void AliPHOSClusterizerv1::UnfoldCluster(AliPHOSEmcRecPoint * iniEmc,
Int_t nMax,
- int * maxAt,
+ AliPHOSDigit ** maxAt,
Float_t * maxAtEnergy)
{
// Performs the unfolding of a cluster with nMax overlapping showers
AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
+
const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
- TClonesArray * digits = gime->Digits() ;
+ const TClonesArray * digits = gime->Digits() ;
TObjArray * emcRecPoints = gime->EmcRecPoints() ;
TObjArray * cpvRecPoints = gime->CpvRecPoints() ;
if(fNumberOfEmcClusters >= emcRecPoints->GetSize())
emcRecPoints->Expand(2*fNumberOfEmcClusters) ;
- (*emcRecPoints)[fNumberOfEmcClusters] = new AliPHOSEmcRecPoint() ;
+ (*emcRecPoints)[fNumberOfEmcClusters] = new AliPHOSEmcRecPoint("") ;
emcRP = (AliPHOSEmcRecPoint *) emcRecPoints->At(fNumberOfEmcClusters);
fNumberOfEmcClusters++ ;
}
if(fNumberOfCpvClusters >= cpvRecPoints->GetSize())
cpvRecPoints->Expand(2*fNumberOfCpvClusters) ;
- (*cpvRecPoints)[fNumberOfCpvClusters] = new AliPHOSCpvRecPoint() ;
+ (*cpvRecPoints)[fNumberOfCpvClusters] = new AliPHOSCpvRecPoint("") ;
emcRP = (AliPHOSEmcRecPoint *) cpvRecPoints->At(fNumberOfCpvClusters);
fNumberOfCpvClusters++ ;
}
// Calculates the Chi square for the cluster unfolding minimization
// Number of parameters, Gradient, Chi squared, parameters, what to do
-
TList * toMinuit = (TList*) gMinuit->GetObjectFit() ;
AliPHOSEmcRecPoint * emcRP = (AliPHOSEmcRecPoint*) toMinuit->At(0) ;
taskName.ReplaceAll(Version(), "") ;
cout << "---------------"<< taskName.Data() << " " << GetTitle()<< "-----------" << endl
- << "Clusterizing digits from the file: " << fHeaderFileName.Data() << endl
- << " Branch: " << fDigitsBranchTitle.Data() << endl
+ << "Clusterizing digits from the file: " << taskName.Data() << endl
+ << " Branch: " << GetName() << endl
<< endl
<< " EMC Clustering threshold = " << fEmcClusteringThreshold << endl
<< " EMC Local Maximum cut = " << fEmcLocMaxCut << endl
{
// Prints list of RecPoints produced at the current pass of AliPHOSClusterizer
- TObjArray * emcRecPoints = AliPHOSGetter::GetInstance()->EmcRecPoints() ;
- TObjArray * cpvRecPoints = AliPHOSGetter::GetInstance()->CpvRecPoints() ;
+ TObjArray * emcRecPoints = AliPHOSGetter::GetInstance()->EmcRecPoints(BranchName()) ;
+ TObjArray * cpvRecPoints = AliPHOSGetter::GetInstance()->CpvRecPoints(BranchName()) ;
cout << "AliPHOSClusterizerv1: : event "<<gAlice->GetEvNumber() << endl ;
cout << " Found "<< emcRecPoints->GetEntriesFast() << " EMC Rec Points and "
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff