#include <TTUBE.h>
#include <TTree.h>
#include <TNode.h>
+#include <TFile.h>
#include <TClonesArray.h>
#include <TLorentzVector.h>
#include "AliFMDv1.h"
#include "AliRun.h"
#include "AliMC.h"
+#include "AliDetector.h"
#include <iostream.h>
#include <fstream.h>
#include "AliMagF.h"
#include "AliFMDhit.h"
#include "AliFMDdigit.h"
+#include "AliFMDReconstruction.h"
#include <stdlib.h>
-ClassImp(AliFMD)
-
+ClassImp (AliFMD)
//_____________________________________________________________________________
- AliFMD::AliFMD(): AliDetector()
+AliFMD::AliFMD ():AliDetector ()
{
//
// Default constructor for class AliFMD
//
- fIshunt = 0;
+ fIshunt = 0;
+ fHits = 0;
+ fDigits = 0;
+ fSDigits = 0;
+ fReconParticles=0;
}
-
+
//_____________________________________________________________________________
-AliFMD::AliFMD(const char *name, const char *title)
- : AliDetector(name,title)
+AliFMD::AliFMD (const char *name, const char *title):
+AliDetector (name, title)
{
//
// Standard constructor for Forward Multiplicity Detector
//
-
+
//
// Initialise Hit array
- fHits = new TClonesArray("AliFMDhit", 1000);
+ fHits = new TClonesArray ("AliFMDhit", 1000);
// Digits for each Si disk
- fDigits = new TClonesArray("AliFMDdigit", 1000);
- fSDigits = new TClonesArray("AliFMDdigit", 1000) ;
- gAlice->AddHitList(fHits);
+ fDigits = new TClonesArray ("AliFMDdigit", 1000);
+ fSDigits = new TClonesArray ("AliFMDdigit", 1000);
+ gAlice->AddHitList (fHits);
- fIshunt = 0;
- fIdSens1 = 0;
+ fIshunt = 0;
+ fIdSens1 = 0;
- SetMarkerColor(kRed);
+ SetMarkerColor (kRed);
}
-
-AliFMD::~AliFMD()
+//-----------------------------------------------------------------------------
+AliFMD::~AliFMD ()
{
- if (fHits) {
- fHits->Delete();
+ if (fHits)
+ {
+ fHits->Delete ();
delete fHits;
fHits = 0;
- }
- if (fDigits) {
- fDigits->Delete();
+ }
+ if (fDigits)
+ {
+ fDigits->Delete ();
delete fDigits;
fDigits = 0;
- }
- if (fSDigits) {
- fSDigits->Delete();
+ }
+ if (fSDigits)
+ {
+ fSDigits->Delete ();
delete fSDigits;
fSDigits = 0;
- }
-
+ }
+ if (fReconParticles)
+ {
+ fReconParticles->Delete ();
+ delete fReconParticles;
+ fReconParticles = 0;
+ }
+
}
+
//_____________________________________________________________________________
-void AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits)
+void AliFMD::AddHit (Int_t track, Int_t * vol, Float_t * hits)
{
//
// Add a hit to the list
//
- TClonesArray &lhits = *fHits;
- new(lhits[fNhits++]) AliFMDhit(fIshunt,track,vol,hits);
+ TClonesArray & lhits = *fHits;
+ new (lhits[fNhits++]) AliFMDhit (fIshunt, track, vol, hits);
}
+
//_____________________________________________________________________________
-void AliFMD::AddDigit( Int_t *digits)
+void AliFMD::AddDigit (Int_t * digits)
{
// add a real digit - as coming from data
// printf("AddDigit\n");
- TClonesArray &ldigits = *fDigits;
- new(ldigits[fNdigits++]) AliFMDdigit(digits);
+ TClonesArray & ldigits = *fDigits;
+ new (ldigits[fNdigits++]) AliFMDdigit (digits);
}
+
//_____________________________________________________________________________
-void AliFMD::BuildGeometry()
+void AliFMD::BuildGeometry ()
{
//
// Build simple ROOT TNode geometry for event display
//
TNode *node, *top;
- const int kColorFMD = 7;
+ const int kColorFMD = 7;
//
- top=gAlice->GetGeometry()->GetNode("alice");
+ top = gAlice->GetGeometry ()->GetNode ("alice");
// FMD define the different volumes
- new TRotMatrix("rot901","rot901", 90, 0, 90, 90, 180, 0);
-
- new TTUBE("S_FMD0","FMD volume 0","void",4.73,17.7,1.5);
- top->cd();
- node = new TNode("FMD0","FMD0","S_FMD0",0,0,64,"");
- node->SetLineColor(kColorFMD);
- fNodes->Add(node);
-
- new TTUBE("S_FMD1","FMD volume 1","void",23.4,36.,1.5);
- top->cd();
- node = new TNode("FMD1","FMD1","S_FMD1",0,0,85,"");
- node->SetLineColor(kColorFMD);
- fNodes->Add(node);
-
- new TTUBE("S_FMD2","FMD volume 2","void",4.73,17.7,1.5);
- top->cd();
- node = new TNode("FMD2","FMD2","S_FMD2",0,0,-64,"");
- node->SetLineColor(kColorFMD);
- fNodes->Add(node);
-
- new TTUBE("S_FMD3","FMD volume 3","void",23.4,36.,1.5);
- top->cd();
- node = new TNode("FMD3","FMD3","S_FMD3",0,0,-85,"");
- node->SetLineColor(kColorFMD);
- fNodes->Add(node);
-
- new TTUBE("S_FMD4","FMD volume 4","void",5,15,0.015);
- top->cd();
- node = new TNode("FMD4","FMD4","S_FMD4",0,0,-270,"");
- node->SetLineColor(kColorFMD);
- fNodes->Add(node);
-
-
- new TTUBE("S_FMD5","FMD volume 5","void",5,14,0.015);
- top->cd();
- node = new TNode("FMD5","FMD5","S_FMD5",0,0,-630,"");
- node->SetLineColor(kColorFMD);
- fNodes->Add(node);
-
+ new TRotMatrix ("rot901", "rot901", 90, 0, 90, 90, 180, 0);
+
+ new TTUBE ("S_FMD0", "FMD volume 0", "void", 4.73, 17.7, 1.5);
+ top->cd ();
+ node = new TNode ("FMD0", "FMD0", "S_FMD0", 0, 0, 64, "");
+ node->SetLineColor (kColorFMD);
+ fNodes->Add (node);
+
+ new TTUBE ("S_FMD1", "FMD volume 1", "void", 23.4, 36., 1.5);
+ top->cd ();
+ node = new TNode ("FMD1", "FMD1", "S_FMD1", 0, 0, 85, "");
+ node->SetLineColor (kColorFMD);
+ fNodes->Add (node);
+
+ new TTUBE ("S_FMD2", "FMD volume 2", "void", 4.73, 17.7, 1.5);
+ top->cd ();
+ node = new TNode ("FMD2", "FMD2", "S_FMD2", 0, 0, -64, "");
+ node->SetLineColor (kColorFMD);
+ fNodes->Add (node);
+
+ new TTUBE ("S_FMD3", "FMD volume 3", "void", 23.4, 36., 1.5);
+ top->cd ();
+ node = new TNode ("FMD3", "FMD3", "S_FMD3", 0, 0, -85, "");
+ node->SetLineColor (kColorFMD);
+ fNodes->Add (node);
+
+ new TTUBE ("S_FMD4", "FMD volume 4", "void", 5, 15, 0.015);
+ top->cd ();
+ // node = new TNode("FMD4","FMD4","S_FMD4",0,0,-270,"");
+ node = new TNode ("FMD4", "FMD4", "S_FMD4", 0, 0, -270, "");
+ node->SetLineColor (kColorFMD);
+ fNodes->Add (node);
+
+ /*
+ new TTUBE("S_FMD5","FMD volume 5","void",5,14,0.015);
+ top->cd();
+ node = new TNode("FMD5","FMD5","S_FMD5",0,0,-630,"");
+ node->SetLineColor(kColorFMD);
+ fNodes->Add(node);
+ */
}
-
+
//_____________________________________________________________________________
-Int_t AliFMD::DistanceToPrimitive(Int_t px, Int_t py)
+Int_t AliFMD::DistanceToPrimitive (Int_t px, Int_t py)
{
//
// Calculate the distance from the mouse to the FMD on the screen
//
return 9999;
}
+
//___________________________________________
-void AliFMD::ResetHits()
+void AliFMD::ResetHits ()
{
// Reset number of clusters and the cluster array for this detector
- AliDetector::ResetHits();
+ AliDetector::ResetHits ();
}
//____________________________________________
-void AliFMD::ResetDigits()
+void AliFMD::ResetDigits ()
{
- //
- // Reset number of digits and the digits array for this detector
- AliDetector::ResetHits();
- //
+ //
+ // Reset number of digits and the digits array for this detector
+ AliDetector::ResetHits ();
+ //
}
//-------------------------------------------------------------------------
-void AliFMD::Init()
+void AliFMD::Init ()
{
//
// Initialis the FMD after it has been built
Int_t i;
- AliMC* pMC = AliMC::GetMC();
+ AliMC *pMC = AliMC::GetMC ();
//
- if(fDebug) {
- printf("\n%s: ",ClassName());
- for(i=0;i<35;i++) printf("*");
- printf(" FMD_INIT ");
- for(i=0;i<35;i++) printf("*");
- printf("\n%s: ",ClassName());
- //
- // Here the FMD initialisation code (if any!)
- for(i=0;i<80;i++) printf("*");
- printf("\n");
- }
+ if (fDebug)
+ {
+ printf ("\n%s: ", ClassName ());
+ for (i = 0; i < 35; i++)
+ printf ("*");
+ printf (" FMD_INIT ");
+ for (i = 0; i < 35; i++)
+ printf ("*");
+ printf ("\n%s: ", ClassName ());
+ //
+ // Here the FMD initialisation code (if any!)
+ for (i = 0; i < 80; i++)
+ printf ("*");
+ printf ("\n");
+ }
//
//
- if (IsVersion()!=0)
- fIdSens1=pMC->VolId("GRIN"); //Si sensetive volume
+ if (IsVersion () != 0)
+ fIdSens1 = pMC->VolId ("GRIN"); //Si sensetive volume
else
- fIdSens1=pMC->VolId("GFSI"); //Si sensetive volume
+ fIdSens1 = pMC->VolId ("GFSI"); //Si sensetive volume
}
+
//---------------------------------------------------------------------
-void AliFMD::MakeBranch(Option_t* option, const char *file)
+void AliFMD::MakeBranch (Option_t * option, const char *file)
{
// Create Tree branches for the FMD.
- const Int_t kBufferSize = 4000;
char branchname[10];
- sprintf(branchname,"%s",GetName());
+ const Int_t kBufferSize = 16000;
+ sprintf (branchname, "%s", GetName ());
+
+ AliDetector::MakeBranch (option, file);
+ const char *cD = strstr(option,"D");
+ const char *cR = strstr(option,"R");
+ const char *cS = strstr(option,"S");
+
+ if (cS){
- AliDetector::MakeBranch(option,file);
+ MakeBranchInTree(gAlice->TreeS(),
+ branchname,&fSDigits,
+ kBufferSize, file);
+ }
+ if (cD){
- const char *cD = strstr(option,"D");
-
- if (cD) {
-
MakeBranchInTree(gAlice->TreeD(),
- branchname, &fDigits, kBufferSize, file);
-
- printf("Making Branch %s for digits\n",branchname);
- gAlice->TreeD()->Print();
+ branchname,&fDigits,
+ kBufferSize, file);
+ }
+ if (cR){
+ MakeBranchInTree(gAlice->TreeR(),
+ branchname,&fReconParticles,
+ kBufferSize, file);
}
+
}
-
+
//_____________________________________________________________________________
-void AliFMD::SetTreeAddress()
+void AliFMD::SetTreeAddress ()
{
// Set branch address for the Hits and Digits Tree.
char branchname[30];
- AliDetector::SetTreeAddress();
+ AliDetector::SetTreeAddress ();
TBranch *branch;
- TTree *treeD = gAlice->TreeD();
+ TTree *treeD = gAlice->TreeD ();
- if (treeD) {
- if (fDigits) {
- branch = treeD->GetBranch(branchname);
- if (branch) branch->SetAddress(&fDigits);
- }
-
- }
- if(fSDigits)
- fSDigits->Clear();
+ if (treeD)
+ {
+ if (fDigits)
+ {
+ branch = treeD->GetBranch (branchname);
+ if (branch)
+ branch->SetAddress (&fDigits);
+ }
- if (gAlice->TreeS() && fSDigits ) {
- branch = gAlice->TreeS()->GetBranch("FMD");
- if (branch) branch->SetAddress(&fSDigits) ;
- }
+ }
+ if (fSDigits)
+ fSDigits->Clear ();
+
+ if (gAlice->TreeS () && fSDigits)
+ {
+ branch = gAlice->TreeS ()->GetBranch ("FMD");
+ if (branch)
+ branch->SetAddress (&fSDigits);
+ }
+ if(fReconParticles)
+ fReconParticles->Clear();
+ if (gAlice->TreeR())
+ {
+ branch = gAlice->TreeR()->GetBranch("FMD");
+ if (branch) branch->SetAddress(&fReconParticles) ;
+ }
}
//---------------------------------------------------------------------
-/*
+
void AliFMD::SDigits2Digits()
{
- Int_t ibg=0, bgr=0;
- Int_t nbgr_ev= 0;
-
- if (ibg) {
- printf("nbgr_ev %d\n",nbgr_ev);
- // Hit2Digits(nbgr_ev,"Add"," ","galice_bgr.root");
- }
- else {
- // Hit2Digits(nbgr_ev,"rien","","");
+ cout<<"AliFMD::SDigits2Digits"<<endl;
+ if (fMerger) {
+ cout<<"AliFMD::SDigits2Digits fMerger"<<fMerger<<endl;
+ fMerger->Init();
+ cout<<"AliFMD::SDigits2Digits Init"<<endl;
+
+ fMerger->Digitise();
}
}
-*/
+//---------------------------------------------------------------------
+void AliFMD::SetMerger(AliFMDMerger* merger)
+{
+// Set pointer to merger
+ fMerger = merger;
+}
+
+AliFMDMerger* AliFMD::Merger()
+{
+// Return pointer to merger
+ return fMerger;
+}
+
//---------------------------------------------------------------------
-void AliFMD::Eta2Radius(Float_t eta, Float_t zDisk, Float_t *radius)
+void
+AliFMD::Eta2Radius (Float_t eta, Float_t zDisk, Float_t * radius)
{
- Float_t expEta=TMath::Exp(-eta);
- Float_t theta=TMath::ATan(expEta);
- theta=2.*theta;
- Float_t rad=zDisk*(TMath::Tan(theta));
- *radius=rad;
-
- if(fDebug) printf("%s: eta %f radius %f\n", ClassName(), eta, rad);
+ Float_t expEta = TMath::Exp (-eta);
+ Float_t theta = TMath::ATan (expEta);
+ theta = 2. * theta;
+ Float_t rad = zDisk * (TMath::Tan (theta));
+ *radius = rad;
+
+ if (fDebug)
+ printf ("%s: eta %f radius %f\n", ClassName (), eta, rad);
}
//---------------------------------------------------------------------
-void AliFMD::Hits2SDigits(){
- if(fDebug) cout << ClassName() << ": ALiFMD::Hits2SDigits> start...\n";
- // char * fileSDigits = 0 ;
- // char * fileHeader=0 ;
- AliFMDSDigitizer * sd = new AliFMDSDigitizer("mgalice.root","FMD.SDigit.root") ;
- sd->Exec("") ;
- sd->Print("");
-
- delete sd ;
-}
+void AliFMD::Hits2SDigits ()
+{
+
+ AliFMD *FMD = (AliFMD *) gAlice->GetDetector ("FMD");
+
+ if (fNevents == 0)
+ fNevents = (Int_t) gAlice->TreeE ()->GetEntries ();
+
+ for (Int_t ievent = 0; ievent < fNevents; ievent++)
+ {
+ gAlice->GetEvent (ievent);
+ if (gAlice->TreeH () == 0)
+ return;
+ if (gAlice->TreeS () == 0)
+ gAlice->MakeTree ("S");
+
+
+ Int_t nSdigits = 0;
+
+ //Make branches
+ char branchname[20];
+ sprintf (branchname, "%s", FMD->GetName ());
+ //Make branch for digits
+ FMD->MakeBranch ("S");
+
+
+ //Now made SDigits from hits, for PHOS it is the same
+ Int_t volume, sector, ring, charge;
+ Float_t e;
+ Float_t de[10][20][150];
+ Int_t ivol, isec, iring;
+ Int_t hit, nbytes;
+ TParticle *particle;
+ AliFMDhit *fmdHit;
+ TClonesArray *FMDhits = FMD->Hits ();
+
+ // Event ------------------------- LOOP
+
+ for (ivol = 1; ivol <= 5; ivol++)
+ for (isec = 1; isec <= 16; isec++)
+ for (iring = 1; iring <= 128; iring++)
+ de[ivol][isec][iring] = 0;
+
+ if (FMD)
+ {
+ FMDhits = FMD->Hits ();
+ TTree *TH = gAlice->TreeH ();
+ Stat_t ntracks = TH->GetEntries ();
+ for (Int_t track = 0; track < ntracks; track++)
+ {
+ gAlice->ResetHits ();
+ nbytes += TH->GetEvent (track);
+ particle = gAlice->Particle (track);
+ Int_t nhits = FMDhits->GetEntriesFast ();
+
+ for (hit = 0; hit < nhits; hit++)
+ {
+ fmdHit = (AliFMDhit *) FMDhits->UncheckedAt (hit);
+
+ volume = fmdHit->Volume ();
+ sector = fmdHit->NumberOfSector ();
+ ring = fmdHit->NumberOfRing ();
+ e = fmdHit->Edep ();
+ de[volume][sector][ring] = de[volume][sector][ring] + e;
+ } //hit loop
+ } //track loop
+ } //if FMD
+
+
+ Int_t digit[5];
+ Float_t I = 1.664 * 0.04 * 2.33 / 22400; // = 0.69e-6;
+ for (ivol = 1; ivol <= 5; ivol++)
+ {
+ for (isec = 1; isec <= 16; isec++)
+ {
+ for (iring = 1; iring <= 128; iring++)
+ {
+ digit[0] = ivol;
+ digit[1] = isec;
+ digit[2] = iring;
+ charge = Int_t (de[ivol][isec][iring] / I);
+ digit[3] = charge;
+ // if (charge!=0) cout<<" charge "<<charge<<endl;
+ //dinamic diapason from MIP(0.155MeV) to 30MIP(4.65MeV)
+ //1024 ADC channels
+ Float_t channelWidth = (22400 * 30) / 1024;
+ digit[4] = Int_t (digit[3] / channelWidth);
+
+ new ((*fSDigits)[nSdigits++]) AliFMDdigit (digit);
+
+ } // iring loop
+ } //sector loop
+ } // volume loop
+
+ gAlice->TreeS ()->Fill ();
+ gAlice->TreeS ()->Print ();
+
+ } //event loop
+}
+//-----------------------------------------------------------------------
+
+void AliFMD::Digits2Reco()
+{
+#ifdef DEBUG
+ cout<<"ALiFMD::Digits2Reco> start...";
+#endif
+ char * fileReconParticles=0;
+ char * fileHeader=0;
+ AliFMDReconstruction * reconstruction =
+ new AliFMDReconstruction(fileHeader,fileReconParticles) ;
+ fReconParticles=new TClonesArray("AliFMDReconstParticles",1000);
+ reconstruction->Exec(fReconParticles,"");
+ delete reconstruction;
+}
#include "AliDetector.h"
#include "TString.h"
+#include "AliFMDMerger.h"
class TFile;
class TTree;
+ class AliFMDMerger;
class AliFMD : public AliDetector {
public:
virtual void StepManager() {}
void Eta2Radius(Float_t, Float_t, Float_t*);
void Hits2SDigits();//
+ void Digits2Reco();
// Digitisation
TClonesArray *SDigits() const {return fSDigits;}
// virtual void SDigits2Digits();
-
+ virtual void SDigits2Digits();
+ virtual void SetMerger(AliFMDMerger* merger);
+ virtual AliFMDMerger* Merger();
+ TClonesArray *ReconParticles() const {return fReconParticles;}
+ Int_t fNevents ; // Number of events to digitize
+
protected:
Int_t fIdSens1; //Si sensetive volume
+ AliFMDMerger *fMerger; // ! pointer to merger
TClonesArray *fSDigits ; // List of summable digits
- ClassDef(AliFMD,2) //Class for the FMD detector
+ TClonesArray *fReconParticles;
+
+ ClassDef(AliFMD,3) //Class for the FMD detector
};
#endif // AliFMD_H
+
+
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/*
+$Log$
+Revision 1.3 2001/03/05 23:57:44 morsch
+Writing of digit tree moved to macro.
+
+Revision 1.2 2001/03/05 08:40:25 morsch
+Method SortTracks(..) imported from AliMUON.
+
+Revision 1.1 2001/02/02 14:11:53 morsch
+AliMUONMerger prototype to be called by the merge manager.
+
+*/
+
+#include <TTree.h>
+#include <TVector.h>
+#include <TObjArray.h>
+#include <TFile.h>
+#include <TDirectory.h>
+
+
+#include "AliFMDMerger.h"
+#include "AliFMD.h"
+#include "AliFMDSDigitizer.h"
+#include "AliFMDhit.h"
+#include "AliFMDdigit.h"
+
+#include "AliRun.h"
+#include "AliPDG.h"
+
+#include <stdlib.h>
+#include <iostream.h>
+#include <fstream.h>
+
+ClassImp(AliFMDMerger)
+
+//___________________________________________
+ AliFMDMerger::AliFMDMerger()
+{
+// Default constructor
+ fEvNrSig = 0;
+ fEvNrBgr = 0;
+ fMerge =kDigitize;
+ fFnBgr = 0;
+}
+
+//------------------------------------------------------------------------
+AliFMDMerger::~AliFMDMerger()
+{
+// Destructor
+ if(fSDigits) {
+ fSDigits->Delete();
+ delete fSDigits ;
+ fSDigits = 0;
+ }
+}
+
+
+
+//------------------------------------------------------------------------
+void AliFMDMerger::Init()
+{
+// Initialisation
+ if (fMerge) fBgrFile = InitBgr();
+
+}
+
+
+
+//------------------------------------------------------------------------
+TFile* AliFMDMerger::InitBgr()
+{
+// Initialise background event
+ TFile *file = new TFile(fFnBgr);
+// add error checking later
+ printf("\n AliFMDMerger has opened %s file with background event \n", fFnBgr);
+ return file;
+}
+
+//------------------------------------------------------------------------
+void AliFMDMerger::Digitise()
+{
+
+ // keep galice.root for signal and name differently the file for
+ // background when add! otherwise the track info for signal will be lost !
+
+
+
+#ifdef DEBUG
+ cout<<"ALiFMD::>SDigits2Digits start...\n";
+#endif
+
+ AliFMD * FMD = (AliFMD *) gAlice->GetDetector("FMD") ;
+
+ Int_t chargeSum[10][20][150];
+ Int_t digit[5];
+ Int_t ivol, iSector, iRing;
+
+ TFile *f1 =0;
+ TTree *TK = gAlice->TreeK();
+ if (TK) f1 = TK->GetCurrentFile();
+
+ gAlice->GetEvent(fEvNrSig) ;
+
+ if(gAlice->TreeD() == 0)
+ gAlice->MakeTree("D") ;
+ gAlice->TreeD()->Reset();
+
+ //Make branches
+ ReadDigit( chargeSum, fEvNrSig);
+
+ if(fMerge){
+ fBgrFile->cd();
+ // gAlice->TreeS()->Reset();
+ gAlice = (AliRun*)fBgrFile->Get("gAlice");
+ Int_t chargeBgr[10][20][150];
+ ReadDigit( chargeBgr,fEvNrBgr);
+ for ( ivol=1; ivol<=5; ivol++)
+ for ( iSector=1; iSector<=16; iSector++)
+ for ( iRing=1; iRing<=128; iRing++)
+ chargeSum[ivol][iSector][iRing]=
+ chargeBgr[ivol][iSector][iRing]+
+ chargeSum[ivol][iSector][iRing];
+
+ } //if merge
+
+
+ // Put noise and make ADC signal
+ for ( ivol=1; ivol<=5; ivol++){
+ for ( iSector=1; iSector<=16; iSector++){
+ for ( iRing=1; iRing<=128; iRing++){
+ digit[0]=ivol;
+ digit[1]=iSector;
+ digit[2]=iRing;
+ digit[3]=PutNoise(chargeSum[ivol][iSector][iRing]);
+ if(chargeSum[ivol][iSector][iRing] <= 500) digit[3]=500;
+
+ //dinamic diapason from MIP(0.155MeV) to 30MIP(4.65MeV)
+ //1024 ADC channels
+ Float_t channelWidth=(22400*50)/1024;
+ digit[4]=Int_t(digit[3]/channelWidth);
+ if (digit[4]>1024) digit[4]=1024;
+
+ FMD->AddDigit(digit);
+
+ } //ivol
+ } //iSector
+ } //iRing
+
+ f1->cd();
+
+ //Make branch for digits
+ FMD->MakeBranch("D");
+
+ gAlice->TreeD()->Reset();
+ gAlice->TreeD()->Fill();
+
+ fDigits = FMD->Digits();
+
+ gAlice->TreeD()->Write(0,TObject::kOverwrite) ;
+
+ gAlice->ResetDigits();
+
+}
+
+//---------------------------------------------------------------------
+
+void AliFMDMerger::ReadDigit(Int_t chargeSum[][20][150], Int_t iEvNum)
+{
+ AliFMDdigit *fmddigit;
+
+ for (Int_t i=0; i<10; i++)
+ for(Int_t j=0; j<20; j++)
+ for(Int_t ij=0; ij<150; ij++)
+ chargeSum[i][j][ij]=0;
+
+ AliFMD * FMD = (AliFMD *) gAlice->GetDetector("FMD") ;
+
+ gAlice->GetEvent(iEvNum) ;
+ if(gAlice->TreeS()==0) {
+ cout<<" TreeS==0 -> return"<<gAlice->TreeS()<<endl;
+ return ;}
+
+ Int_t ndig, k;
+ gAlice->ResetDigits();
+ gAlice->TreeS()->GetEvent(iEvNum);
+ TClonesArray * FMDdigits = FMD->SDigits();
+
+ ndig=FMDdigits->GetEntries();
+
+ for (k=0; k<ndig; k++) {
+ fmddigit= (AliFMDdigit*) FMDdigits->UncheckedAt(k);
+
+ Int_t iVolume=fmddigit->Volume();
+ Int_t iNumberOfSector =fmddigit->NumberOfSector();
+ Int_t iNumberOfRing=fmddigit->NumberOfRing();
+ chargeSum[iVolume][iNumberOfSector][iNumberOfRing]=fmddigit->Charge();
+ }
+}
+
+
--- /dev/null
+#ifndef ALIFMDMERGER_H
+#define ALIFMDMERGER_H
+/* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+// #include "AliMerger.h"
+// #include "AliMergable.h"
+#include "TRandom.h"
+#include "AliDetector.h"
+
+typedef enum {kDigitize=0, kMerge = 1} MergeMode_t;
+
+class AliFMDMerger {
+ public:
+
+ AliFMDMerger();
+ virtual ~AliFMDMerger();
+
+
+ // Initialize merging and digitisation
+ virtual void Init();
+
+ // Do the main work
+ void Digitise() ;
+ Int_t PutNoise(Int_t charge){return (Int_t)(gRandom->Gaus(charge,500));}
+ TClonesArray *SDigits() const {return fSDigits;}
+ // TClonesArray *Digits() const {return fDigits;}
+
+ void ReadDigit(Int_t a[][20][150], Int_t);
+
+ // Setters -> Later Communication with gAlice
+ void SetSignalEventNumber(Int_t i) {fEvNrSig = i;}
+ void SetBackgroundEventNumber(Int_t i) {fEvNrBgr = i;}
+ void SetBackgroundFileName(char* file) {fFnBgr = file;}
+ void SetSignalFileName(char* file) {fFnSig = file;}
+ void SetMode(MergeMode_t mode) {fMerge = mode;}
+
+ enum {kBgTag = -1};
+
+ private:
+ // Open the bgr file
+ TFile *InitBgr();
+
+ private:
+ TClonesArray *fDigits; // ! array with digits
+ // Int_t fDigits;
+ TClonesArray *fSDigits ; // List of summable digits
+ Int_t fEvNrSig; // signal event number
+ Int_t fEvNrBgr; // background event number
+ MergeMode_t fMerge; // merging type kDigitize, kMerge
+ char *fFnBgr; // background file name
+ char *fFnSig; // signal file name
+ TFile *fBgrFile; // Pointer to background file
+
+ ClassDef(AliFMDMerger,0)
+};
+#endif
+
--- /dev/null
+#include "AliFMDReconstParticles.h"
+
+ClassImp(AliFMDReconstParticles)
+
+AliFMDReconstParticles::AliFMDReconstParticles()
+{
+ fNumOfDet=0;
+ fNumOfSector=0;
+ fNumOfRing=0;
+ fNumOfReconstParticles=0;
+}
+AliFMDReconstParticles::AliFMDReconstParticles(Int_t *RecParticles)
+{
+ fNumOfDet=RecParticles[0];
+ fNumOfSector=RecParticles[1];
+ fNumOfRing=RecParticles[2];
+ fNumOfReconstParticles=RecParticles[3];
+}
+Int_t AliFMDReconstParticles::GetVolume(){return fNumOfDet;}
+Int_t AliFMDReconstParticles::GetNumberOfSector() {return fNumOfSector;}
+Int_t AliFMDReconstParticles::GetNumberOfRing() {return fNumOfRing;}
+Int_t AliFMDReconstParticles::GetNumberOfReconstParticles() {return fNumOfReconstParticles;}
+
--- /dev/null
+#ifndef AliFMDReconstParticles_h
+#define AliFMDReconstParticles_h
+
+#include <TClonesArray.h>
+#include <TObject.h>
+class AliFMDReconstParticles: public TObject
+{
+ //Reconstracted Particles Class
+ private:
+ Int_t fNumOfDet; //Number of FMD disk;
+ Int_t fNumOfSector; //Number of sector
+ Int_t fNumOfRing; //Number of ring
+ Int_t fNumOfReconstParticles; //Number of reconstructed particles
+
+ public:
+ AliFMDReconstParticles();
+ AliFMDReconstParticles (Int_t *RecParticles);
+ virtual ~AliFMDReconstParticles(){};
+ Int_t GetVolume(); //Return the number of volume
+ Int_t GetNumberOfSector(); //Return the number of sector
+ Int_t GetNumberOfRing(); //Return the number of ring
+ Int_t GetNumberOfReconstParticles(); //Returnthe number of reconstructed particles
+ ClassDef(AliFMDReconstParticles,1)
+};
+#endif
--- /dev/null
+// --- ROOT system ---
+#include "TTask.h"
+#include "TTree.h"
+#include "TSystem.h"
+#include "TFile.h"
+// --- Standard library ---
+
+// --- AliRoot header files ---
+
+#include "AliFMDdigit.h"
+#include "AliFMDReconstParticles.h"
+#include "AliFMD.h"
+#include "AliFMDv1.h"
+#include "AliFMDReconstruction.h"
+#include "AliRun.h"
+#include "AliDetector.h"
+
+#include "TROOT.h"
+#include "TFolder.h"
+#include <stdlib.h>
+#include <iostream.h>
+#include <fstream.h>
+
+ClassImp(AliFMDReconstruction)
+
+
+//____________________________________________________________________________
+
+AliFMDReconstruction::AliFMDReconstruction():TTask("AliFMDReconstruction","")
+{
+ fNevents = 0 ; // Number of events to rreconnstraction, 0 means all events in current file
+ // add Task to //root/Tasks folder
+ TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ;
+ roottasks->Add(this) ;
+}
+//____________________________________________________________________________
+
+AliFMDReconstruction::AliFMDReconstruction(char* HeaderFile, char *ReconstParticlesFile):TTask("AliFMDReconstruction","")
+{
+ fNevents = 0 ; // Number of events to rreconnstraction, 0 means all events in current file
+ fReconstParticlesFile=ReconstParticlesFile ;
+ fHeadersFile=HeaderFile ;
+ //add Task to //root/Tasks folder
+ TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ;
+ roottasks->Add(this) ;
+}
+
+//____________________________________________________________________________
+
+AliFMDReconstruction::~AliFMDReconstruction()
+{
+
+}
+
+//____________________________________________________________________________
+
+void AliFMDReconstruction::Exec(TClonesArray *fReconParticles,Option_t *option)
+{
+ //Collects all digits in the same active volume into number of particles
+
+ AliFMD * FMD = (AliFMD *) gAlice->GetDetector("FMD");
+ if(fNevents == 0) fNevents=(Int_t)gAlice->TreeD()->GetEntries();
+ for(Int_t ievent=0;ievent<fNevents;ievent++)
+ {
+ gAlice->GetEvent(ievent) ;
+ if(gAlice->TreeH()==0) return;
+ if(gAlice->TreeR()==0) gAlice->MakeTree("R");
+ //Make branches
+ FMD->MakeBranch("R");
+ Int_t threshold[]={ 0, 18, 37, 56, 76,
+ 96, 119, 138, 165, 172,
+ 218, 231, 238, 277, 304,
+ 330, 357, 423, 449, 476,
+ 522, 542, 555, 568, 581,
+ 614, 624, 657, 674, 687,
+ 700, 713, 720, 727, 733,
+ 740, 759, 778, 797, 816,
+ 834, 853, 872, 891, 910,
+ 929, 948, 967, 986, 1024};
+
+
+ int threshold_array_size=sizeof(threshold)/sizeof(threshold[0]);
+ AliFMDdigit *fmdDigit;
+
+ if (FMD)
+ {
+ gAlice->TreeD()->GetEvent(0);
+ TClonesArray *FMDdigits=FMD->Digits();
+ Int_t nDigits=FMDdigits->GetEntries();
+ Int_t RecParticles[4];
+ Int_t nRecPart=0 ;
+ for (Int_t digit=0;digit<nDigits;digit++)
+ {
+ fmdDigit=(AliFMDdigit*)FMDdigits->UncheckedAt(digit);
+ RecParticles[0] = fmdDigit->Volume();
+ RecParticles[1] = fmdDigit->NumberOfSector();
+ RecParticles[2] = fmdDigit->NumberOfRing();
+ Int_t ADC=fmdDigit->ADCsignal();
+ RecParticles[3]=0; //case when fmdDigit->ADCsignal()==0
+ for (int i=0;i<threshold_array_size-1;i++)
+ {
+ if(ADC>threshold[i]&&ADC<=threshold[i+1])
+ RecParticles[3]=i;
+ }
+ new((*fReconParticles)[nRecPart++]) AliFMDReconstParticles(RecParticles);
+ } //digit loop
+ }//if FMD
+ gAlice->TreeR()->Reset();
+ gAlice->TreeR()->Fill();
+ gAlice->TreeR()->Write(0,TObject::kOverwrite);
+ } //event loop
+ cout<<"\nAliFMDReconstruction::Exec(TClonesArray *fReconParticles,Option_t *option) finished"<<endl;
+}
+//__________________________________________________________________
+
+void AliFMDReconstruction::SetReconstParticlesFile(char * file )
+{
+ if (!fReconstParticlesFile.IsNull())
+ cout<<"\nChanging reconstructed particles file from "<<
+ (char *) fReconstParticlesFile.Data()<< " to "<<file<<endl;
+ fReconstParticlesFile=file;
+}
+//__________________________________________________________________
+void AliFMDReconstruction::Print(Option_t* option)const
+{
+ cout<<"------------------- "<<GetName() <<" -------------"<< endl ;
+ if(fReconstParticlesFile.IsNull())
+ cout<<"\nWriting reconstructed particles to file"<<endl ;
+ else
+ cout<<"\nWriting reconstructed particles to file "<<
+ (char*) fReconstParticlesFile.Data() << endl ;
+}
+
+
+
+
+
--- /dev/null
+#ifndef AliFMDReconstruction_h
+//#define AliFMDReconstruction_h 1
+#define AliFMDReconstruction_h
+
+// --- ROOT system ---
+#include "TTask.h"
+#include "TString.h"
+#include "AliFMD.h"
+#include "AliDetector.h"
+
+// --- Standard library ---
+
+// --- AliRoot header files ---
+
+class AliFMDReconstruction: public TTask
+{
+ public:
+ AliFMDReconstruction() ;
+ AliFMDReconstruction(char* HeaderFile,char *SdigitsFile = 0) ;
+ virtual ~AliFMDReconstruction();
+ char *GetReconstParticlesFile()const{return (char*) fReconstParticlesFile.Data();}
+ virtual void Exec(TClonesArray *fReconParticles,Option_t *option);
+ void SetNEvents(Int_t Nevents){fNevents = Nevents;}
+ Stat_t GetNEvents(){return fNevents;}
+ void SetReconstParticlesFile(char * file ) ;
+ virtual void Print(Option_t* option) const ;
+ //TClonesArray *ReconParticles() const {return fReconParticles;}
+
+ private:
+ Int_t fNevents ; // Number of events to digitize
+ TString fReconstParticlesFile; //output file
+ TString fHeadersFile ; //input file
+ // TClonesArray *fReconParticles;
+ ClassDef(AliFMDReconstruction,1)
+};
+#endif
+
+
+
+
+
+
+
+
+
Int_t Charge();
Int_t ADCsignal();
- ClassDef(AliFMDdigit,2) // Real data digit object for set:ITS
+ ClassDef(AliFMDdigit,1) // Real data digit object for set:ITS
};
inline Int_t AliFMDdigit::Volume(){return fNumOfDet;}
inline Int_t AliFMDdigit::NumberOfSector() {return fNumOfSector;}
Float_t Py();
Float_t Pz();
Float_t Time();
- ClassDef(AliFMDhit,2) //Hits for detector FMD
+ ClassDef(AliFMDhit,1) //Hits for detector FMD
};
inline Int_t AliFMDhit::Volume(){return fVolume;}
inline Int_t AliFMDhit::NumberOfSector(){return fNumberOfSector;}
#include "AliMC.h"
#include <iostream.h>
#include <fstream.h>
-//#include <AliRandom.h>
+#include "/afs/cern.ch/alice/offline/new/RALICE/AliRandom.h"
#include "AliMagF.h"
#include "AliFMDhit.h"
#include <stdlib.h>
for (ifmd =0; ifmd < 6; ifmd++){
sprintf(name,"FMD%d",ifmd);
- if(fDebug)
- printf("%s: %s",ClassName(),name);
+ printf(name);
zfmd=TMath::Abs(z[ifmd]);
- if(fDebug) printf("zfmd %f z[ifmd] %f",zfmd,z[ifmd]);
+ printf("zfmd %f z[ifmd] %f",zfmd,z[ifmd]);
AliFMD::Eta2Radius(etain[ifmd],zfmd,&rin[ifmd]);
AliFMD::Eta2Radius(etaout[ifmd],zfmd,&rout[ifmd]);
par[2]=zFMD/2;
gMC->Gsvolu(name,"TUBE", idtmed[3], par, 3);
- if(fDebug) printf ("rin %f rout %f ZFMD %f\n",par[0],par[1],z[ifmd]);
+ printf ("rin %f rout %f ZFMD %f\n",par[0],par[1],z[ifmd]);
if (z[ifmd] < 0){
gMC->Gspos(name,1,"ALIC",0,0,z[ifmd],0, "ONLY");}
else {
AliMC* gMC=AliMC::GetMC();
AliFMD::Init();
fIdSens1=gMC->VolId("GFSI");
-if(fDebug) printf("%s: *** FMD version 0 initialized ***\n",ClassName());
+printf("*** FMD version 0 initialized ***\n");
}
//-------------------------------------------------------------------
char name[5];
Float_t rin[6], rout[6],zpos;
- Float_t etain[6]= {3.3, 2.0, 3.3, 2.0, 4.7, 5.5};
- Float_t etaout[6]={2.0, 1.6, 2.0, 1.6, 3.6, 4.5};
- Float_t z[6]={64., 85., -64., -85., -270., -630};
+ Float_t etain[6]= {3.3, 2.0, 3.3, 2.0, 4.5, 5.5};
+ Float_t etaout[6]={2.0, 1.6, 2.0, 1.6, 3.3, 4.5};
+ // Float_t z[6]={64., 85., -64., -85., -270., -630};
+ Float_t z[6]={64., 85., -64., -85., -240., -630};
Float_t zDet=0.04;
Float_t zElectronic=0.75;
Float_t zSupport=1.;
gMC->Gsvolu("GEL ","TUBE", idtmed[4], par, 0);
gMC->Gsvolu("GSUP","TUBE", idtmed[2], par, 0);
- for (ifmd =0; ifmd < 4; ifmd++){
+ for (ifmd =0; ifmd < 5; ifmd++){
sprintf(name,"FMD%d",ifmd);
- if(fDebug)
- printf("%s: %s",ClassName(),name);
+ printf(name);
zfmd=TMath::Abs(z[ifmd]);
- if(fDebug) printf("zfmd %f z[ifmd] %f",zfmd,z[ifmd]);
+ printf("zfmd %f z[ifmd] %f",zfmd,z[ifmd]);
AliFMD::Eta2Radius(etain[ifmd],zfmd,&rin[ifmd]);
AliFMD::Eta2Radius(etaout[ifmd],zfmd,&rout[ifmd]);
par[2]=zFMD/2;
gMC->Gsvolu(name,"TUBE", idtmed[3], par, 3);
- if(fDebug) printf ("rin %f rout %f ZFMD %f\n",par[0],par[1],z[ifmd]);
+ printf ("rin %f rout %f ZFMD %f\n",par[0],par[1],z[ifmd]);
if (z[ifmd] < 0){
gMC->Gspos(name,1,"ALIC",0,0,z[ifmd],0, "ONLY");}
else {
{
// Initialises version 0 of the Forward Multiplicity Detector
//
- AliMC* gMC=AliMC::GetMC();
- AliFMD::Init();
- fIdSens1=gMC->VolId("GRIN");
- if(fDebug) printf("%s: *** FMD version 1 initialized ***\n",ClassName());
+AliMC* gMC=AliMC::GetMC();
+AliFMD::Init();
+fIdSens1=gMC->VolId("GRIN");
+printf("*** FMD version 1 initialized ***\n");
}
//-------------------------------------------------------------------
vol[1]=copy1;
gMC->CurrentVolOffID(2,copy2);
vol[0]=copy2;
+ // printf("vol0 %d vol1 %d vol2 %d\n",vol[0],vol[1],vol[2]);
gMC->TrackPosition(pos);
hits[0]=pos[0];
hits[1]=pos[1];
hits[2]=pos[2];
+ // printf(" Zpos %f \n",hits[2]);
gMC->TrackMomentum(mom);
hits[3]=mom[0];
hits[4]=mom[1];
} // IsTrackExiting()
}
}
+//--------------------------------------------------------------------------
+
+void AliFMDv1::Response( Float_t Edep)
+{
+ Float_t I=1.664*0.04*2.33/22400; // = 0.69e-6;
+ Float_t chargeOnly=Edep/I;
+ //Add noise ~500electrons
+ Int_t charge=500;
+ if (Edep>0)
+ charge=Int_t(gRandom->Gaus(chargeOnly,500));
+ }
////////////////////////////////////////////////
#include "AliFMD.h"
-#include "AliFMDSDigitizer.h"
class AliFMDv1 : public AliFMD {
virtual void Init();
virtual Int_t IsVersion() const {return 0;}
virtual void StepManager();
+ // virtual void Hit2Digits(Int_t bgrEvent, Option_t *opt1=" ",
+ // Option_t *opt2=" ",Text_t *name=" "); // hit to digit for v1 :test
+ virtual void Response( Float_t Edep);
+//private:
+ //Int_t fCharge;
+
protected:
Int_t fIdSens1; // Sensetive volume in FMD
// Background event for event mixing
- Text_t *fFileName; // ! File with background hits
- TTree *fTrH1; // Hits Tree for background event
- TClonesArray *fHits2; // List of hits for one track only
- ClassDef(AliFMDv1,2) //Class for FMD version 0
+ ClassDef(AliFMDv1,2) //Class for FMD version 0
};
#endif
#pragma link C++ class AliFMDv1+;
#pragma link C++ class AliFMDhit+;
#pragma link C++ class AliFMDdigit+;
-#pragma link C++ class AliFMDSDigitizer+;
+#pragma link C++ class AliFMDReconstruction+;
+#pragma link C++ class AliFMDReconstParticles+;
+#pragma link C++ class AliFMDMerger+;
#endif
--- /dev/null
+void FMDMerger (Int_t evNumber1=0, Int_t evNumber2=0, Int_t ibg=0, Int_t bgr=10)
+{
+// Dynamically link some shared libs
+
+ if (gClassTable->GetID("AliRun") < 0) {
+ gROOT->LoadMacro("loadlibs.C");
+ loadlibs();
+ }
+
+// Connect the Root Galice file containing Geometry, Kine and Hits
+
+ TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject("mgalice.root");
+ if (file) file->Close();
+ file = new TFile("mgalice.root","UPDATE");
+ cout<<" Just starting... file "<<file<<endl;
+
+// Get AliRun object from file or create it if not on file
+
+ if (!gAlice) {
+ gAlice = (AliRun*)file->Get("gAlice");
+ if (gAlice) printf("AliRun object found on file\n");
+ if (!gAlice) gAlice = new AliRun("gAlice","Alice test program");
+ }
+ AliFMD *FMD = (AliFMD*) gAlice->GetModule("FMD");
+ cout<<" FMDMerger:: FMD "<<FMD<<" gAlice "<<gAlice<<endl;
+
+ if (FMD) {
+// creation
+ AliFMDMerger* merger = new AliFMDMerger();
+// configuration
+ if (ibg) {
+ merger->SetMode(ibg);
+ merger->SetBackgroundFileName("bg.root");
+ }
+ // pass
+ // merger->SetSignalFileName("mgalice.root");
+ FMD->SetMerger(merger);
+ }
+// Action !
+//
+// Loop over events
+//
+ for (int nev=evNumber1; nev<= evNumber2; nev++) {
+ Int_t nparticles = gAlice->GetEvent(nev);
+ cout << "nev " << nev <<endl;
+ cout << "nparticles " << nparticles <<endl;
+ if (nev < evNumber1) continue;
+ if (nparticles <= 0) return;
+ Int_t nbgr_ev = Int_t(nev*bgr/(evNumber2+1));
+ cout<<" nbgr_ev "<<nbgr_ev<<endl;
+
+ if (ibg) {
+ merger->SetBackgroundEventNumber(nbgr_ev);
+ }
+
+ gAlice->SDigits2Digits("FMD");
+
+ char hname[30];
+ sprintf(hname,"TreeD%d",nev);
+ // gAlice->TreeD()->Write(hname);
+ // cout<<hname<<" was written in file"<<file<<endl;
+ // gAlice->TreeD()->Print();
+ //reset tree
+ gAlice->TreeD()->Reset();
+
+ } // event loop
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
gROOT->LoadMacro("$ALICE_ROOT/macros/loadlibs.C");
loadlibs();
}
- gSystem->Setenv("CONFIG_SPLIT_FILE","1") ;
+ // gSystem->Setenv("CONFIG_SPLIT_FILE","1") ;
if (gSystem->Getenv("CONFIG_SPLIT_FILE"))
cout << "SPLIT" << endl;
else
cout << "NO SPLIT" << endl ;
- TFile * f = new TFile("galice.root","UPDATE");
+ TFile * f = new TFile("mgalice.root","UPDATE");
gAlice = (AliRun*) f->Get("gAlice") ;
cout<<"gAlice="<<gAlice<<endl;
AliFMD* FMD = (AliFMD *)gAlice->GetDetector("FMD") ;
- gAlice->Hits2SDigits("FMD") ;
- }
+ cout<<" FMD "<<FMD<<endl;
+ gAlice->GetEvent(0);
+ gAlice->Hits2SDigits() ;
+ gAlice->TreeS()->Write(0,TObject::kOverwrite) ;
+ }
# C++ sources
-SRCS = AliFMD.cxx AliFMDv0.cxx AliFMDv1.cxx AliFMDhit.cxx\
- AliFMDdigit.cxx AliFMDSDigitizer.cxx
+SRCS = AliFMD.cxx AliFMDv0.cxx AliFMDv1.cxx AliFMDhit.cxx AliFMDdigit.cxx AliFMDMerger.cxx AliFMDReconstruction.cxx AliFMDReconstParticles.cxx
# C++ Headers
default: $(SLIBRARY)
+tst: Hit2Digits.cxx
+ g++ -g $(CXXFLAGS) $(SLIBRARY) Hit2Digits.cxx $(ROOTLIBS) -o tst
+
$(LIBDIR)/libFMD.$(SL): $(OBJS)
$(DICT): $(HDRS)
--- /dev/null
+void TestReconstruction (Int_t evNumber=1)
+{
+ if (gClassTable->GetID("AliRun") < 0)
+ {
+ gROOT->LoadMacro("$ALICE_ROOT/macros/loadlibs.C");
+ loadlibs();
+ }
+ if (gSystem->Getenv("CONFIG_SPLIT_FILE"))
+ cout << "SPLIT" << endl;
+ else
+ cout << "NO SPLIT" << endl ;
+ TFile * f = new TFile("mgalice.root","UPDATE");
+ gAlice = (AliRun*) f->Get("gAlice") ;
+ cout<<"gAlice="<<gAlice<<endl;
+ AliFMD* FMD = (AliFMD *)gAlice->GetDetector("FMD");
+ cout<<"\nFMD="<<FMD<<endl;
+ gAlice->RunReco("FMD") ;
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff