"= %f, Crossing plane = %d\n\n", fFermiflag, fBeamDiv, fBeamCrossAngle,
fBeamCrossPlane);
- FermiTwoGaussian(207.);
+ FermiTwoGaussian(208.);
}
//_____________________________________________________________________________
Float_t lightQ = zdcHit->GetLightPMQ();
Float_t lightC = zdcHit->GetLightPMC();
trackTime = zdcHit->GetTrackTOF();
+ // Signals from ZEM are delayed to arrive in time with ZDC signals
+ if(sector[0] == 3) trackTime += 320;
// Ch. debug
//printf("\t det %d vol %d trackTOF %f lightQ %1.0f lightC %1.0f\n",
// sector[0], sector[1], trackTime, lightQ, lightC);
//____________________________________________________________________________
AliZDCDigitizer::AliZDCDigitizer() :
fIsCalibration(0),
+ fIsSignalInADCGate(kFALSE),
+ fFracLostSignal(0.),
fPedData(0),
fCalibData(0)
{
AliZDCDigitizer::AliZDCDigitizer(AliRunDigitizer* manager):
AliDigitizer(manager),
fIsCalibration(0), //By default the simulation doesn't create calib. data
+ fIsSignalInADCGate(kFALSE),
+ fFracLostSignal(0.),
fPedData(GetPedData()),
fCalibData(GetCalibData())
{
AliZDCDigitizer::AliZDCDigitizer(const AliZDCDigitizer &digitizer):
AliDigitizer(),
fIsCalibration(digitizer.fIsCalibration),
+ fIsSignalInADCGate(digitizer.fIsSignalInADCGate),
+ fFracLostSignal(digitizer.fFracLostSignal),
fPedData(digitizer.fPedData),
fCalibData(digitizer.fCalibData)
{
// !!! 2nd ZDC set added
// *** 1st 3 arrays are digits from REAL (simulated) hits
// *** last 2 are copied from simulated digits
- // --- pm[0][...] = light in ZN right [C, Q1, Q2, Q3, Q4]
- // --- pm[1][...] = light in ZP right [C, Q1, Q2, Q3, Q4]
+ // --- pm[0][...] = light in ZN side C [C, Q1, Q2, Q3, Q4]
+ // --- pm[1][...] = light in ZP side C [C, Q1, Q2, Q3, Q4]
// --- pm[2][...] = light in ZEM [x, 1, 2, x, x]
- // --- pm[3][...] = light in ZN left [C, Q1, Q2, Q3, Q4] ->NEW!
- // --- pm[4][...] = light in ZP left [C, Q1, Q2, Q3, Q4] ->NEW!
+ // --- pm[3][...] = light in ZN side A [C, Q1, Q2, Q3, Q4] ->NEW!
+ // --- pm[4][...] = light in ZP side A [C, Q1, Q2, Q3, Q4] ->NEW!
// ------------------------------------------------------------
Float_t pm[5][5];
for(Int_t iSector1=0; iSector1<5; iSector1++)
// impact parameter and number of spectators
Float_t impPar = -1;
- Int_t specN = 0;
- Int_t specP = 0;
+ Int_t specNTarg = 0, specPTarg = 0;
+ Int_t specNProj = 0, specPProj = 0;
+ Float_t signalTime0;
// loop over input streams
for(Int_t iInput = 0; iInput<fManager->GetNinputs(); iInput++){
sdigit.GetSector(0), sdigit.GetSector(1)));
continue;
}
- //
+ // Checking if signal is inside ADC gate
+ if(iSDigit==0) signalTime0 = sdigit.GetTrackTime();
+ else{
+ // Assuming a signal lenght of 20 ns, signal is in gate if
+ // signal ENDS in signalTime0+50. -> sdigit.GetTrackTime()+20<=signalTime0+50.
+ if(sdigit.GetTrackTime()<=signalTime0+30.) fIsSignalInADCGate = kTRUE;
+ if(sdigit.GetTrackTime()>signalTime0+30.){
+ fIsSignalInADCGate = kFALSE;
+ // Vedi quaderno per spiegazione approx. usata
+ // nel calcolo della fraz. di segnale perso
+ fFracLostSignal = (sdigit.GetTrackTime()-30)*(sdigit.GetTrackTime()-30)/280.;
+ }
+ }
+ Float_t sdSignal = sdigit.GetLightPM();
+ if(fIsSignalInADCGate == kFALSE){
+ AliWarning(Form("\t %f of ZDC signal 4 det.(%d, %d) out of ADC gate\n",
+ fFracLostSignal,sdigit.GetSector(0),sdigit.GetSector(1)));
+ sdSignal = (1-fFracLostSignal)*sdSignal;
+ }
+
pm[(sdigit.GetSector(0))-1][sdigit.GetSector(1)] += sdigit.GetLightPM();
/*printf("\n\t Detector %d, Tower %d -> pm[%d][%d] = %.0f \n",
sdigit.GetSector(0), sdigit.GetSector(1),sdigit.GetSector(0)-1,
sdigit.GetSector(1), pm[sdigit.GetSector(0)-1][sdigit.GetSector(1)]); // Chiara debugging!
*/
+
}
loader->UnloadSDigits();
if(!genHeader->InheritsFrom(AliGenHijingEventHeader::Class())) continue;
impPar = ((AliGenHijingEventHeader*) genHeader)->ImpactParameter();
//
- specN = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsn();
- specP = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsp();
- AliDebug(2, Form("\n AliZDCDigitizer -> b = %f fm, Nspecn = %d, Nspecp = %d\n",
- impPar, specN, specP));
- printf("\n\t AliZDCDigitizer -> b = %f fm, # generated spectator n = %d,"
- " # generated spectator p = %d\n", impPar, specN, specP);
+ specNProj = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsn();
+ specPProj = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsp();
+ specNTarg = ((AliGenHijingEventHeader*) genHeader)->TargSpectatorsn();
+ specPTarg = ((AliGenHijingEventHeader*) genHeader)->TargSpectatorsp();
+ printf("\n\t AliZDCDigitizer: b = %f fm\n"
+ " \t PROJ.: #spectator n %d, #spectator p %d\n"
+ " \t TARG.: #spectator n %d, #spectator p %d\n",
+ impPar, specNProj, specPProj, specNTarg, specPTarg);
}
- // add spectators
+ // Applying fragmentation algorithm and adding spectator signal
if(impPar >= 0) {
- Int_t freeSpecN, freeSpecP;
- Fragmentation(impPar, specN, specP, freeSpecN, freeSpecP);
- printf("\n\t AliZDCDigitizer -> Adding signal for %d free spectator n\n",freeSpecN);
- SpectatorSignal(1, freeSpecN, pm);
- printf("\t AliZDCDigitizer -> Adding signal for %d free spectator p\n\n",freeSpecP);
- SpectatorSignal(2, freeSpecP, pm);
+ Int_t freeSpecNProj, freeSpecPProj;
+ Fragmentation(impPar, specNProj, specPProj, freeSpecNProj, freeSpecPProj);
+ Int_t freeSpecNTarg, freeSpecPTarg;
+ Fragmentation(impPar, specNTarg, specPTarg, freeSpecNTarg, freeSpecPTarg);
+ SpectatorSignal(1, freeSpecNProj, pm);
+ printf(" AliZDCDigitizer -> Signal for %d PROJ free spectator n added\n",freeSpecNProj);
+ SpectatorSignal(2, freeSpecPProj, pm);
+ printf(" AliZDCDigitizer -> Signal for %d PROJ free spectator p added\n",freeSpecPProj);
+ SpectatorSignal(3, freeSpecNTarg, pm);
+ printf(" AliZDCDigitizer -> Signal for %d TARG free spectator n added\n",freeSpecNTarg);
+ SpectatorSignal(4, freeSpecPTarg, pm);
+ printf(" AliZDCDigitizer -> Signal for %d TARG free spectator p added\n",freeSpecPTarg);
}
//_____________________________________________________________________________
void AliZDCDigitizer::SpectatorSignal(Int_t SpecType, Int_t numEvents,
- Float_t pm[3][5]) const
+ Float_t pm[5][5]) const
{
// add signal of the spectators
-
- TFile* file = NULL;
- if(SpecType == 1) { // --- Signal for spectator neutrons
- file = TFile::Open("$ALICE_ROOT/ZDC/ZNsignalntu.root");
- } else if(SpecType == 2) { // --- Signal for spectator protons
- file = TFile::Open("$ALICE_ROOT/ZDC/ZPsignalntu.root");
+
+ TString hfn;
+ if(SpecType == 1) { // --- Signal for projectile spectator neutrons
+ hfn = "$ALICE_ROOT/ZDC/ZNCSignal.root";
+ }
+ else if(SpecType == 2) { // --- Signal for projectile spectator protons
+ hfn = "$ALICE_ROOT/ZDC/ZPCSignal.root";
+ }
+ else if(SpecType == 3) { // --- Signal for target spectator neutrons
+ hfn = "$ALICE_ROOT/ZDC/ZNASignal.root";
+ }
+ else if(SpecType == 4) { // --- Signal for target spectator protons
+ hfn = "$ALICE_ROOT/ZDC/ZPASignal.root";
}
+
+ TFile* file = TFile::Open(hfn);
if(!file || !file->IsOpen()) {
- AliError("Opening of file failed");
+ AliError((Form(" Opening file %s failed\n",hfn.Data())));
return;
}
TNtuple* zdcSignal = (TNtuple*) file->Get("ZDCSignal");
Int_t nentries = (Int_t) zdcSignal->GetEntries();
- Float_t *entry, hitsSpec[7];
- Int_t pl, i, j, k, iev=0, rnd[125], volume[2];
+ Float_t *entry;
+ Int_t pl, i, k, iev=0, rnd[125], volume[2];
for(pl=0;pl<125;pl++) rnd[pl] = 0;
if(numEvents > 125) {
AliWarning(Form("numEvents (%d) is larger than 125", numEvents));
entry = zdcSignal->GetArgs();
if(entry[0] == rnd[iev]){
for(k=0; k<2; k++) volume[k] = (Int_t) entry[k+1];
- for(j=0; j<7; j++) hitsSpec[j] = entry[j+3];
//
- Float_t lightQ = hitsSpec[4];
- Float_t lightC = hitsSpec[5];
- AliDebug(3, Form("SpectatorSignal -> vol = (%d, %d), lightQ = %.0f, lightC = %.0f",
- volume[0], volume[1], lightQ, lightC));
- //printf("\n Volume = (%d, %d), lightQ = %.0f, lightC = %.0f",
- // volume[0], volume[1], lightQ, lightC);
+ Float_t lightQ = entry[7];
+ Float_t lightC = entry[8];
+ //
if(volume[0] != 3) { // ZN or ZP
pm[volume[0]-1][0] += lightC;
pm[volume[0]-1][volume[1]] += lightQ;
Float_t fPMGain[6][5]; // PM gain
Float_t fADCRes[2]; // ADC conversion factors
-
Int_t fIsCalibration; // !=0 if simulation creates calibration data
+ Bool_t fIsSignalInADCGate; // true if signal in ADC gate
+ Float_t fFracLostSignal; // fraction of lost signal
AliZDCPedestals *fPedData; //! pedestal calibration data
AliZDCCalib *fCalibData; //! energy and equalization calibration data
- ClassDef(AliZDCDigitizer, 7) // digitizer for ZDC
+ ClassDef(AliZDCDigitizer, 8) // digitizer for ZDC
};
#endif
Float_t fLightPMC; //Cerenkov light seen by the common PM
Float_t fEnergy; //Total energy deposited in eV
Int_t fPDGCode; //PDG code of particle in the ZDC
- Float_t fTrackTOF; //Track time
+ Float_t fTrackTOF; //Track time in ns
ClassDef(AliZDCHit,3) // Hits for the Zero Degree Calorimeters
};
//_____________________________________________________________________________
AliZDCRecoParam::AliZDCRecoParam() :
- AliDetectorRecoParam(),
- fBeamEnergy(0)
+ AliDetectorRecoParam()
{
//
//Default constructor
AliZDCRecoParam();
virtual ~AliZDCRecoParam();
- Float_t GetBeamEnergy() const {return fBeamEnergy;}
- virtual void SetBeamEnergy(Float_t beamE) {fBeamEnergy = beamE;}
- //
virtual TF1* GetfZNCen() const =0;
virtual TF1* GetfZNPer() const =0;
virtual TF1* GetfZPCen() const =0;
AliZDCRecoParam(const AliZDCRecoParam&);
AliZDCRecoParam& operator =(const AliZDCRecoParam&);
- Float_t fBeamEnergy;// beam energy
-
- ClassDef(AliZDCRecoParam, 1)
+ ClassDef(AliZDCRecoParam, 2)
};
param->SetEZN2MaxValue(161.);
param->SetEZP2MaxValue(59.);
param->SetEZDC2MaxValue(161.);
- //
- param->SetBeamEnergy(2.7);
return param;
// print reconstruction parameters
//
printf("\n\n\t AliZDCRecoParamPbPb -> parameters set for reconstruction\n");
- printf("\t Beam energy (for Pb-Pb): %1.2f TeV\n",fBeamEnergy);
printf("\t Functions for reconstruction of centrality varibles (Pb-Pb):\n");
fZNCen->Print("");
// Makes default reconstruction parameters
//
AliZDCRecoParampp *param = new AliZDCRecoParampp();
- //
- param->SetBeamEnergy(5.);
return param;
// print reconstruction parameters
//
printf("\n\n\t AliZDCRecoParampp -> parameters set for reconstruction\n");
- printf("\t p-p -> beam E : %1.2f TeV\n\n",fBeamEnergy);
}
#include <TF1.h>
+#include <TMap.h>
#include "AliRunLoader.h"
#include "AliRawReader.h"
+#include "AliGRPObject.h"
#include "AliESDEvent.h"
#include "AliESDZDC.h"
#include "AliZDCDigit.h"
//_____________________________________________________________________________
AliZDCReconstructor:: AliZDCReconstructor() :
fPedData(GetPedData()),
- fECalibData(GetECalibData())
+ fECalibData(GetECalibData()),
+ fRecoMode(0),
+ fBeamEnergy(0.)
{
// **** Default constructor
+ SetRecoMode();
}
if(fECalibData) delete fECalibData;
}
+//____________________________________________________________________________
+void AliZDCReconstructor::SetRecoMode()
+{
+ // Setting reconstruction mode
+
+ // Initialization of the GRP entry
+ AliGRPObject* grpData;
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
+ if(entry){
+ TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
+ if(m){
+ m->Print();
+ grpData = new AliGRPObject();
+ grpData->ReadValuesFromMap(m);
+ }
+ else{
+ grpData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
+ entry->SetOwner(0);
+ }
+ AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
+ }
+ if(!grpData) AliError("No GRP entry found in OCDB!");
+
+ TString beamType = grpData->GetBeamType();
+ if(beamType==AliGRPObject::GetInvalidString()){
+ AliError("GRP/GRP/Data entry: missing value for the beam energy !");
+ AliError("\t ZDC does not reconstruct event 4 UNKNOWN beam type\n");
+ return;
+ }
+ //
+ if((beamType.CompareTo("p-p")) == 0){
+ fRecoMode=0;
+ fRecoParam = (AliZDCRecoParampp*) AliZDCRecoParampp::GetppRecoParam();
+ }
+ else if((beamType.CompareTo("A-A")) == 0){
+ fRecoMode=1;
+ fRecoParam = (AliZDCRecoParamPbPb*) AliZDCRecoParamPbPb::GetPbPbRecoParam();
+ }
+
+ fBeamEnergy = grpData->GetBeamEnergy();
+ if(fBeamEnergy==AliGRPObject::GetInvalidFloat()) {
+ AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
+ fBeamEnergy = 0.;
+ }
+
+ printf("\n ***** ZDC reconstruction initialized for %s @ %1.3f GeV\n\n",beamType.Data(), fBeamEnergy);
+}
+
//_____________________________________________________________________________
void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const
{
}
// reconstruct the event
- ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
+ if(fRecoMode==0)
+ ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
+ dZEM1Corr, dZEM2Corr, PMRef1, PMRef2);
+ else if(fRecoMode==1)
+ ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
dZEM1Corr, dZEM2Corr, PMRef1, PMRef2);
}
}
// reconstruct the event
- ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
+ if(fRecoMode==0)
+ ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
+ dZEM1Corr, dZEM2Corr, PMRef1, PMRef2);
+ else if(fRecoMode==1)
+ ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
dZEM1Corr, dZEM2Corr, PMRef1, PMRef2);
}
calibSumZP2[1] += calibTowZP2[gi];
}
}
-
- //
- // --- Reconstruction parameters ------------------
- if(!fRecoParam) fRecoParam = (AliZDCRecoParampp*) AliZDCRecoParampp::GetppRecoParam();
// --- Number of detected spectator nucleons
// *** N.B. -> It works only in Pb-Pb
Int_t nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight;
- Float_t beamE = fRecoParam->GetBeamEnergy();
- nDetSpecNLeft = (Int_t) (calibSumZN1[0]/beamE);
- nDetSpecPLeft = (Int_t) (calibSumZP1[0]/beamE);
- nDetSpecNRight = (Int_t) (calibSumZN2[0]/beamE);
- nDetSpecPRight = (Int_t) (calibSumZP2[0]/beamE);
+ if(fBeamEnergy!=0){
+ nDetSpecNLeft = (Int_t) (calibSumZN1[0]/fBeamEnergy);
+ nDetSpecPLeft = (Int_t) (calibSumZP1[0]/fBeamEnergy);
+ nDetSpecNRight = (Int_t) (calibSumZN2[0]/fBeamEnergy);
+ nDetSpecPRight = (Int_t) (calibSumZP2[0]/fBeamEnergy);
+ }
+ else AliWarning(" ATTENTION -> fBeamEnergy = 0\n");
/*printf("\n\t AliZDCReconstructor -> nDetSpecNLeft %d, nDetSpecPLeft %d,"
" nDetSpecNRight %d, nDetSpecPRight %d\n",nDetSpecNLeft, nDetSpecPLeft,
nDetSpecNRight, nDetSpecPRight);*/
// --- Number of detected spectator nucleons
// *** N.B. -> It works only in Pb-Pb
Int_t nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight;
- Float_t beamE = fRecoParam->GetBeamEnergy();
- nDetSpecNLeft = (Int_t) (calibSumZN1[0]/beamE);
- nDetSpecPLeft = (Int_t) (calibSumZP1[0]/beamE);
- nDetSpecNRight = (Int_t) (calibSumZN2[0]/beamE);
- nDetSpecPRight = (Int_t) (calibSumZP2[0]/beamE);
+ if(fBeamEnergy!=0){
+ nDetSpecNLeft = (Int_t) (calibSumZN1[0]/fBeamEnergy);
+ nDetSpecPLeft = (Int_t) (calibSumZP1[0]/fBeamEnergy);
+ nDetSpecNRight = (Int_t) (calibSumZN2[0]/fBeamEnergy);
+ nDetSpecPRight = (Int_t) (calibSumZP2[0]/fBeamEnergy);
+ }
+ else AliWarning(" ATTENTION -> fBeamEnergy = 0\n");
/*printf("\n\t AliZDCReconstructor -> nDetSpecNLeft %d, nDetSpecPLeft %d,"
" nDetSpecNRight %d, nDetSpecPRight %d\n",nDetSpecNLeft, nDetSpecPLeft,
nDetSpecNRight, nDetSpecPRight);*/
//
esd->SetZDC(reco.GetZN1HREnergy(), reco.GetZP1HREnergy(), reco.GetZEM1HRsignal(),
reco.GetZEM2HRsignal(), reco.GetZN2HREnergy(), reco.GetZP2HREnergy(),
- reco.GetNPartLeft(),reco.GetNPartRight());
+ reco.GetNPartLeft(), reco.GetNPartRight());
//
}
{FillZDCintoESD(clustersTree,esd);}
virtual void FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, AliESDEvent* esd) const
{FillZDCintoESD(clustersTree,esd);}
-
+
// parameter settings for reconstruction
+ void SetRecoMode();
static void SetRecoParam(AliZDCRecoParam * param){fRecoParam = param;}
+
+ Int_t GetRecoMode() {return fRecoMode;}
static const AliZDCRecoParam* GetRecoParam(){return fRecoParam;}
// OCDB objects for reconstruction
AliZDCPedestals *fPedData; //! pedestal calibration data
AliZDCCalib *fECalibData; //! energy and equalization calibration data
+ Int_t fRecoMode; // =0->p-p, =1->A-A
+ Float_t fBeamEnergy; // beam energy
- ClassDef(AliZDCReconstructor, 4) // class for the ZDC reconstruction
+ ClassDef(AliZDCReconstructor, 5) // class for the ZDC reconstruction
};
#endif
#include <TParticle.h>
// --- AliRoot classes
+#include "AliLog.h"
#include "AliConst.h"
#include "AliMagF.h"
#include "AliRun.h"
if(xdet[1]<=0.) vol[1]=2;
else vol[1]=4;
}
- if((vol[1]!=1) && (vol[1]!=2) && (vol[1]!=3) && (vol[1]!=4))
- printf(" ZDC StepManager->ERROR in ZN!!! vol[1] = %d, xdet[0] = %f,"
- "xdet[1] = %f\n",vol[1], xdet[0], xdet[1]);
}
else if(vol[0]==2){ //Quadrant in ZPC
break;
}
}
- if((vol[1]!=1) && (vol[1]!=2) && (vol[1]!=3) && (vol[1]!=4))
- printf(" ZDC StepManager->ERROR in ZP!!! vol[1] = %d, xdet[0] = %f,"
- "xdet[1] = %f\n",vol[1], xdet[0], xdet[1]);
}
//
// Quadrant in ZEM: vol[1] = 1 -> particle in 1st ZEM (placed at x = 8.5 cm)
if(xdet[1]<=0.) vol[1]=2;
else vol[1]=4;
}
- if((vol[1]!=1) && (vol[1]!=2) && (vol[1]!=3) && (vol[1]!=4))
- printf(" ZDC StepManager->ERROR in ZNA!!! vol[1] = %d, xdet[0] = %f,"
- "xdet[1] = %f\n",vol[1], xdet[0], xdet[1]);
}
//
else if(vol[0]==5){ //Quadrant in ZPA
break;
}
}
- if((vol[1]!=1) && (vol[1]!=2) && (vol[1]!=3) && (vol[1]!=4))
- printf(" ZDC StepManager->ERROR in ZPA!!! vol[1] = %d, xdet[0] = %f,"
- "xdet[1] = %f\n",vol[1], xdet[0], xdet[1]);
}
-
+ if((vol[1]!=1) && (vol[1]!=2) && (vol[1]!=3) && (vol[1]!=4))
+ AliError(Form("AliZDCv3 -> WRONG tower for det %d: tow %d with xdet=(%f, %f)\n",
+ vol[0], vol[1], xdet[0], xdet[1]));
+ // Ch. debug
+ //printf("\t *** det %d vol %d xdet(%f, %f)\n",vol[0], vol[1], xdet[0], xdet[1]);
// Store impact point and kinetic energy of the ENTERING particle