#include "AliAODMCHeader.h"
#include "TGraph.h"
#include "TF1.h"
-#include "TProfile2D.h"
#include "AliAODEvent.h"
#include "AliAODForwardMult.h"
#include "AliAODCentralMult.h"
+#include "AliGenEventHeader.h"
+#include "AliAnalysisManager.h"
+#include "AliInputEventHandler.h"
+#include "AliGenEventHeaderTunedPbPb.h"
ClassImp(AliForwardMCFlowTaskQC)
#if 0
//_____________________________________________________________________
AliForwardMCFlowTaskQC::AliForwardMCFlowTaskQC()
: AliForwardFlowTaskQC(),
- fBinsFMDTR(), // List of FMDTR analysis objects
- fBinsSPDTR(), // List of SPDTR analysis objects
- fBinsMC(), // List of MC truth analysis objects
- fdNdedpMC(), // MC truth d^2N/detadphi histogram
+ fBinsForwardTR(), // List of FMDTR analysis objects
+ fBinsCentralTR(), // List of SPDTR analysis objects
+ fBinsMC(), // List of MC particle analysis objects
+ fAODMCHeader(), // MC Header
+ fHistdNdedpMC(), // MC particle d^2N/detadphi histogram
+ fHistFMDMCCorr(), // FMD MC correlation
+ fHistSPDMCCorr(), // SPD MC correlation
fWeights(), // Flow weights
fImpactParToCent(), // Impact parameter to centrality graph
fUseImpactPar(0), // Use impact par for centrality
- fAddFlow(0), // Add flow to MC truth
- fAddType(0), // Add type of flow to MC truth
- fAddOrder(0) // Add order of flow to MC truth
+ fUseMCVertex(0), // Get vertex from MC header?
+ fAddFlow(0), // Add flow to MC particles
+ fAddType(0), // Add type of flow to MC particles
+ fAddOrder(0) // Add order of flow to MC particles
{}
//
// Default Constructor
//_____________________________________________________________________
AliForwardMCFlowTaskQC::AliForwardMCFlowTaskQC(const char* name)
: AliForwardFlowTaskQC(name),
- fBinsFMDTR(), // List of FMDTR analysis objects
- fBinsSPDTR(), // List of SPDTR analysis objects
- fBinsMC(), // List of MC truth analysis objects
- fdNdedpMC(), // MC truth d^2N/detadphi histogram
+ fBinsForwardTR(), // List of FMDTR analysis objects
+ fBinsCentralTR(), // List of SPDTR analysis objects
+ fBinsMC(), // List of MC particles analysis objects
+ fAODMCHeader(0), // MC Header
+ fHistdNdedpMC(), // MC particles d^2N/detadphi histogram
+ fHistFMDMCCorr(), // FMD MC correlation
+ fHistSPDMCCorr(), // SPD MC correlation
fWeights(), // Flow weights
fImpactParToCent(), // Impact parameter to centrality graph
fUseImpactPar(0), // Use impact par for centrality
- fAddFlow(0), // Add flow to MC truth
- fAddType(0), // Add type of flow to MC truth
- fAddOrder(0) // Add order of flow to MC truth
+ fUseMCVertex(0), // Get vertex from MC header?
+ fAddFlow(0), // Add flow to MC particles
+ fAddType(0), // Add type of flow to MC particles
+ fAddOrder(0) // Add order of flow to MC particles
{
//
// Constructor
//_____________________________________________________________________
AliForwardMCFlowTaskQC::AliForwardMCFlowTaskQC(const AliForwardMCFlowTaskQC& o)
: AliForwardFlowTaskQC(o),
- fBinsFMDTR(), // List of FMDTR analysis objects
- fBinsSPDTR(), // List of SPDTR analysis objects
- fBinsMC(), // List of MC truth analysis objects
- fdNdedpMC(o.fdNdedpMC), // MC truth d^2N/detadphi histogram
+ fBinsForwardTR(), // List of FMDTR analysis objects
+ fBinsCentralTR(), // List of SPDTR analysis objects
+ fBinsMC(), // List of MC particles analysis objects
+ fAODMCHeader(o.fAODMCHeader), // MC Header
+ fHistdNdedpMC(o.fHistdNdedpMC), // MC particles d^2N/detadphi histogram
+ fHistFMDMCCorr(o.fHistFMDMCCorr), // FMD MC correlation
+ fHistSPDMCCorr(o.fHistSPDMCCorr), // SPD MC correlation
fWeights(o.fWeights), // Flow weights
fImpactParToCent(o.fImpactParToCent), // Impact parameter to centrality
fUseImpactPar(o.fUseImpactPar), // Use impact par for centrality
- fAddFlow(o.fAddFlow), // Add flow to MC truth
- fAddType(o.fAddType), // Add type of flow to MC truth
- fAddOrder(o.fAddOrder) // Add order of flow to MC truth
+ fUseMCVertex(o.fUseMCVertex), // Get vertex from MC header?
+ fAddFlow(o.fAddFlow), // Add flow to MC particles
+ fAddType(o.fAddType), // Add type of flow to MC particles
+ fAddOrder(o.fAddOrder) // Add order of flow to MC particles
{
//
// Copy Constructor
// o Object to copy from
//
if (&o == this) return *this;
- fdNdedpMC = o.fdNdedpMC;
+ fAODMCHeader = o.fAODMCHeader;
+ fHistdNdedpMC = o.fHistdNdedpMC;
+ fHistFMDMCCorr = o.fHistFMDMCCorr;
+ fHistSPDMCCorr = o.fHistSPDMCCorr;
fWeights = o.fWeights;
fImpactParToCent = o.fImpactParToCent;
fUseImpactPar = o.fUseImpactPar;
+ fUseMCVertex = o.fUseMCVertex;
fAddFlow = o.fAddFlow;
fAddType = o.fAddType;
fAddOrder = o.fAddOrder;
//
AliForwardFlowTaskQC::InitVertexBins();
- Int_t moment = 0;
- for(UShort_t n = 0; n < fV.GetSize(); n++) {
- moment = fV.At(n);
- for (Int_t v = 1; v <= fVtxAxis->GetNbins(); v++) {
- Int_t vL = Int_t(fVtxAxis->GetBinLowEdge(v));
- Int_t vH = Int_t(fVtxAxis->GetBinUpEdge(v));
- fBinsFMDTR.Add(new VertexBin(vL, vH, moment, "FMDTR", fFlowFlags, fFMDCut, fEtaGap));
- fBinsSPDTR.Add(new VertexBin(vL, vH, moment, "SPDTR", fFlowFlags, fSPDCut, fEtaGap));
- fBinsMC.Add(new VertexBin(vL, vH, moment, "MC", fFlowFlags, -1, fEtaGap));
+ Bool_t isNUA = (fFlowFlags & kNUAcorr);
+ for (Int_t v = 1; v <= fVtxAxis->GetNbins(); v++) {
+ Int_t vL = Int_t(fVtxAxis->GetBinLowEdge(v));
+ Int_t vH = Int_t(fVtxAxis->GetBinUpEdge(v));
+ // FMD
+ if ((fFlowFlags & kFMD)) {
+ fBinsForwardTR.Add(new VertexBin(vL, vH, fMaxMoment, "FMDTR", fFlowFlags, fFMDCut, fEtaGap));
+ if (!(fFlowFlags & k3Cor))
+ fBinsCentralTR.Add(new VertexBin(vL, vH, fMaxMoment, "SPDTR", fFlowFlags|kSPD, fSPDCut, fEtaGap));
+ if (isNUA) fFlowFlags ^= kNUAcorr;
+ fBinsMC.Add(new VertexBin(vL, vH, fMaxMoment, "MC-FMD", fFlowFlags|kMC, -1, fEtaGap));
+ if ((fFlowFlags & kStdQC))
+ fBinsMC.Add(new VertexBin(vL, vH, fMaxMoment, "MC-SPD", fFlowFlags|kMC|kSPD, -1, fEtaGap));
+ if (isNUA) fFlowFlags ^= kNUAcorr;
+ }
+ // VZERO
+ else if ((fFlowFlags & kVZERO)) {
+ fBinsMC.Add(new VertexBin(vL, vH, fMaxMoment, "MC-VZERO", fFlowFlags|kMC, -1, fEtaGap));
}
}
}
//
AliForwardFlowTaskQC::InitHists();
- fdNdedpMC = TH2D(Form("fdNdedpMC%s", ((fFlowFlags & kEtaGap) ? "_etaGap" : "")),
- Form("fdNdedpMC%s", ((fFlowFlags & kEtaGap) ? "_etaGap" : "")),
- 48, -6., 6., 200, 0., 2.*TMath::Pi());
- fdNdedpMC.Sumw2();
+ TString subDetName = ((fFlowFlags & kFMD) ? "FMD" : ((fFlowFlags & kVZERO) ? "VZERO" : "none"));
+ fHistdNdedpMC = TH2D(Form("fdNdedpMC%s%s", subDetName.Data(), GetQCType(fFlowFlags)),
+ Form("fdNdedpMC%s%s", subDetName.Data(), GetQCType(fFlowFlags)),
+ 240, -6., 6., 200, 0., TMath::TwoPi());
+
+ fHistFMDMCCorr = new TH2D("hFMDMCCorr", "hFMDMCCorr", 200, 0., 15000., 200, 0, 20000);
+ fHistSPDMCCorr = new TH2D("hSPDMCCorr", "hSPDMCCorr", 200, 0., 7500., 200, 0, 20000);
+ TList* dList = (TList*)fSumList->FindObject("Diagnostics");
+ if (!dList) {
+ dList = new TList();
+ dList->SetName("Diagnostics");
+ fSumList->Add(dList);
+ }
+ dList->Add(fHistFMDMCCorr);
+ dList->Add(fHistSPDMCCorr);
- TIter nextFMDTR(&fBinsFMDTR);
+ TIter nextForwardTR(&fBinsForwardTR);
VertexBin* bin = 0;
- while ((bin = static_cast<VertexBin*>(nextFMDTR()))) {
- bin->AddOutput(fSumList);
+ while ((bin = static_cast<VertexBin*>(nextForwardTR()))) {
+ bin->AddOutput(fSumList, fCentAxis);
}
- TIter nextSPDTR(&fBinsSPDTR);
- while ((bin = static_cast<VertexBin*>(nextSPDTR()))) {
- bin->AddOutput(fSumList);
+ TIter nextCentralTR(&fBinsCentralTR);
+ while ((bin = static_cast<VertexBin*>(nextCentralTR()))) {
+ bin->AddOutput(fSumList, fCentAxis);
}
TIter nextMC(&fBinsMC);
while ((bin = static_cast<VertexBin*>(nextMC()))) {
- bin->AddOutput(fSumList);
+ bin->AddOutput(fSumList, fCentAxis);
}
TList* wList = new TList();
if (!AliForwardFlowTaskQC::Analyze()) return kFALSE;
// Run analysis on trackrefs from FMD and SPD
- const AliAODForwardMult* aodfmult =
- static_cast<AliAODForwardMult*>(fAOD->FindListObject("ForwardMC"));
- const AliAODCentralMult* aodcmult =
- static_cast<AliAODCentralMult*>(fAOD->FindListObject("CentralClustersMC"));
+ AliAODForwardMult* aodfmult = static_cast<AliAODForwardMult*>(fAOD->FindListObject("ForwardMC"));
+ AliAODCentralMult* aodcmult = static_cast<AliAODCentralMult*>(fAOD->FindListObject("CentralClustersMC"));
Int_t vtx = fVtxAxis->FindBin(fVtx)-1;
// if objects are present, get histograms
if (aodfmult) {
- const TH2D& fmdTRdNdetadphi = aodfmult->GetHistogram();
- if ((fFlowFlags & kEtaGap)) {
- FillVtxBinListEtaGap(fBinsFMDTR, fmdTRdNdetadphi, fmdTRdNdetadphi, vtx);
- } else {
- FillVtxBinList(fBinsFMDTR, fmdTRdNdetadphi, vtx);
+ TH2D& fmdTRdNdetadphi = aodfmult->GetHistogram();
+ if ((fFlowFlags & kStdQC)) {
+ FillVtxBinList(fBinsForwardTR, fmdTRdNdetadphi, vtx);
+ } else if ((fFlowFlags & kEtaGap)) {
+ FillVtxBinListEtaGap(fBinsForwardTR, fmdTRdNdetadphi, fmdTRdNdetadphi, vtx/*, kDoVtxCut*/);
}
if (aodcmult) {
- const TH2D& spdTRdNdetadphi = aodcmult->GetHistogram();
- if ((fFlowFlags & kEtaGap)) {
- FillVtxBinListEtaGap(fBinsSPDTR, fmdTRdNdetadphi, spdTRdNdetadphi, vtx);
- } else {
- FillVtxBinList(fBinsSPDTR, spdTRdNdetadphi, vtx);
+ TH2D& spdTRdNdetadphi = aodcmult->GetHistogram();
+ if ((fFlowFlags & kStdQC)) {
+ FillVtxBinList(fBinsCentralTR, spdTRdNdetadphi, vtx);
+ } else if ((fFlowFlags & kEtaGap)) {
+ FillVtxBinListEtaGap(fBinsCentralTR, fmdTRdNdetadphi, spdTRdNdetadphi, vtx/*, kDoVtxCut*/);
+ } else if ((fFlowFlags & k3Cor)) {
+ FillVtxBinList3Cor(fBinsForwardTR, spdTRdNdetadphi, fmdTRdNdetadphi, vtx);
}
}
}
-
// Run analysis on MC branch
- if (!LoopAODMC()) return kFALSE;
- if ((fFlowFlags & kEtaGap)) {
- FillVtxBinListEtaGap(fBinsMC, fdNdedpMC, fdNdedpMC, vtx);
- } else {
- FillVtxBinList(fBinsMC, fdNdedpMC, vtx);
+ if (!FillMCHist()) return kFALSE;
+ if ((fFlowFlags & kStdQC)) {
+ FillVtxBinList(fBinsMC, fHistdNdedpMC, vtx);
+ } else if ((fFlowFlags & kEtaGap)) {
+ FillVtxBinListEtaGap(fBinsMC, fHistdNdedpMC, fHistdNdedpMC, vtx);
+ } else if ((fFlowFlags & k3Cor)) {
+ FillVtxBinList3Cor(fBinsMC, fHistdNdedpMC, fHistdNdedpMC, vtx);
+ }
+
+ // Mult correlation diagnostics
+ if (aodfmult && aodcmult) {
+ AliAODForwardMult* fmult = static_cast<AliAODForwardMult*>(fAOD->FindListObject("Forward"));
+ AliAODCentralMult* cmult = static_cast<AliAODCentralMult*>(fAOD->FindListObject("CentralClusters"));
+ const TH2D& fhist = fmult->GetHistogram();
+ const TH2D& chist = cmult->GetHistogram();
+
+ Double_t totForward = fhist.Integral(1, fhist.GetNbinsX(), 1, fhist.GetNbinsY());
+ Double_t totSPD = chist.Integral(1, chist.GetNbinsX(), 1, chist.GetNbinsY());
+ Double_t totMC = fHistdNdedpMC.Integral(1, fHistdNdedpMC.GetNbinsX(), 1, fHistdNdedpMC.GetNbinsY());
+ fHistFMDMCCorr->Fill(totForward, totMC);
+ fHistSPDMCCorr->Fill(totSPD, totMC);
}
return kTRUE;
//
AliForwardFlowTaskQC::Finalize();
- EndVtxBinList(fBinsFMDTR);
- EndVtxBinList(fBinsSPDTR);
+ EndVtxBinList(fBinsForwardTR);
+ EndVtxBinList(fBinsCentralTR);
EndVtxBinList(fBinsMC);
return;
}
//_____________________________________________________________________
+Bool_t AliForwardMCFlowTaskQC::CheckEvent(const AliAODForwardMult* aodfm)
+{
+ //
+ // Function to check that an AOD event meets the cuts
+ //
+ // Parameters:
+ // AliAODForwardMult: forward mult object with trigger and vertex info
+ //
+ // Return: false if there is no trigger or if the centrality or vertex
+ // is out of range. Otherwise true.
+ //
+ fAODMCHeader = static_cast<AliAODMCHeader*>(fAOD->FindListObject(AliAODMCHeader::StdBranchName()));
+ return AliForwardFlowTaskQC::CheckEvent(aodfm);
+}
+//_____________________________________________________________________
Bool_t AliForwardMCFlowTaskQC::CheckTrigger(const AliAODForwardMult* aodfm) const
{
//
//
// Returns true if B trigger is present - for some reason this is the one we use in MC
//
- return aodfm->IsTriggerBits(AliAODForwardMult::kB);
+ if (aodfm) return aodfm->IsTriggerBits(AliAODForwardMult::kB);
+ else return (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
+ ->IsEventSelected() & AliVEvent::kMB);
+
}
// _____________________________________________________________________
Bool_t AliForwardMCFlowTaskQC::GetCentrality(const AliAODForwardMult* aodfm)
//
// Returns true when centrality is set.
//
- if (fUseImpactPar) {
- fCent = GetCentFromB();
- if (fCent != -1) return kTRUE;
+ AliGenEventHeaderTunedPbPb* header =
+ dynamic_cast<AliGenEventHeaderTunedPbPb*>(fAODMCHeader->GetCocktailHeader(0));
+ if (header) fCent = header->GetCentrality();
+ else if (fUseImpactPar) fCent = GetCentFromB();
+ else return AliForwardFlowTaskQC::GetCentrality(aodfm);
+
+ if (fCentAxis->GetXmin() > fCent || fCent >= fCentAxis->GetXmax()) {
+ fHistEventSel->Fill(kInvCent);
+ return kFALSE;
}
- return AliForwardFlowTaskQC::GetCentrality(aodfm);
+ if (fCent != 0) return kTRUE;
+ else {
+ fHistEventSel->Fill(kNoCent);
+ return kFALSE;
+ }
+}
+//_____________________________________________________________________
+Bool_t AliForwardMCFlowTaskQC::GetVertex(const AliAODForwardMult* aodfm)
+{
+ //
+ // Function to look for vertex determination in the event using the MC header.
+ //
+ // Parameters:
+ // AliAODForwardMult: Not used
+ //
+ // Returns true if vertex is determined
+ //
+ if (fUseMCVertex) {
+ if (fAODMCHeader) {
+ fVtx = fAODMCHeader->GetVtxZ();
+ if (fVtx < fVtxAxis->GetXmin() || fVtx > fVtxAxis->GetXmax()) {
+ fHistEventSel->Fill(kInvVtx);
+ return kFALSE;
+ }
+ return kTRUE;
+ } else {
+ fHistEventSel->Fill(kNoVtx);
+ return kFALSE;
+ }
+ } else
+ return AliForwardFlowTaskQC::GetVertex(aodfm);
}
//_____________________________________________________________________
-Bool_t AliForwardMCFlowTaskQC::LoopAODMC()
+Bool_t AliForwardMCFlowTaskQC::FillMCHist()
{
//
// Loop over AliAODParticle branch and fill d^2N/detadphi-histograms.
// Add flow if set to do so in AddTask function
//
- fdNdedpMC.Reset();
+ fHistdNdedpMC.Reset();
+ Double_t minEta = -3.75;
+ Double_t maxEta = 5.;
//retreive MC particles from event
TClonesArray* mcArray =
- static_cast<TClonesArray*>(fAOD->FindListObject(
- AliAODMCParticle::StdBranchName()));
+ static_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
if(!mcArray){
AliWarning("No MC array found in AOD. Try making it again.");
return kFALSE;
}
- Double_t rp = 0;
- AliAODMCHeader* header =
- dynamic_cast<AliAODMCHeader*>(fAOD->FindListObject(
- AliAODMCHeader::StdBranchName()));
- if (!header)
- AliWarning("No header file found.");
- else
- rp = header->GetReactionPlaneAngle();
+ if (!fAODMCHeader) AliWarning("No MC header found.");
Int_t ntracks = mcArray->GetEntriesFast();
-
+// Double_t rp = -1, b = -1;
+ if (fAODMCHeader) {
+// rp = header->GetReactionPlaneAngle();
+// b = header->GetImpactParameter();
+ if (fAODMCHeader->GetNCocktailHeaders() > 1) {
+ ntracks = fAODMCHeader->GetCocktailHeader(0)->NProduced();
+ }
+ }
+
UShort_t flowFlags = 0;
if (fAddFlow.Length() > 1) {
if (fAddFlow.Contains("pt")) flowFlags |= AliForwardFlowWeights::kPt;
if (fAddFlow.Contains("eta")) flowFlags |= AliForwardFlowWeights::kEta;
if (fAddFlow.Contains("cent")) flowFlags |= AliForwardFlowWeights::kCent;
}
- Double_t b = -1.;
- b = header->GetImpactParameter();
- // Track loop: chek how many particles will be accepted
- Double_t weight = 0;
- for (Int_t it = 0; it < ntracks; it++) {
- weight = 1;
+ for (Int_t it = 0; it < ntracks; it++) { // Track loop
+ Double_t weight = 1;
AliAODMCParticle* particle = (AliAODMCParticle*)mcArray->At(it);
if (!particle) {
AliError(Form("Could not receive track %d", it));
continue;
}
- if (!particle->IsPhysicalPrimary()) continue;
+ if (!particle->IsPrimary()) continue;
if (particle->Charge() == 0) continue;
//Double_t pT = particle->Pt();
Double_t eta = particle->Eta();
Double_t phi = particle->Phi();
- if (eta > -4. && eta < 5.) {
+ if (eta >= minEta && eta < maxEta) {
// Add flow if it is in the argument
- /* FLOW WEIGHTS DISABLED IN THE VERSION - COMING BACK SOON
- if (flowFlags != 0) {
+ // FLOW WEIGHTS DISABLED IN THE VERSION - COMING BACK SOON
+// if (flowFlags != 0) {
// weight = fWeights.CalcWeight(eta, pT, phi, particle->PdgCode(),
// rp, fCent, fAddType, fAddOrder,
// flowFlags) + 1;
- weight = fWeights.CalcWeight(eta, pT, phi, particle->PdgCode(),
- rp, b);
+// weight = fWeights.CalcWeight(eta, pT, phi, particle->PdgCode(),
+// rp, b);
// Printf("%f", weight);
- }*/
- fdNdedpMC.Fill(eta, phi, weight);
+// }
+ fHistdNdedpMC.Fill(eta, phi, weight);
}
}
- Int_t sBin = fdNdedpMC.GetXaxis()->FindBin(-4.);
- Int_t eBin = fdNdedpMC.GetXaxis()->FindBin(+5.);
- for ( ; sBin < eBin; sBin++) fdNdedpMC.SetBinContent(sBin, 0, 1.);
+ // Set underflow bins for acceptance checks
+ Int_t sBin = fHistdNdedpMC.GetXaxis()->FindBin(minEta);
+ Int_t eBin = fHistdNdedpMC.GetXaxis()->FindBin(maxEta);
+ for ( ; sBin <= eBin; sBin++) {
+ fHistdNdedpMC.SetBinContent(sBin, 0, 1);
+ } // End of eta bin loop
return kTRUE;
}
// Get centrality from MC impact parameter.
//
Double_t cent = -1.;
- Double_t b = -1.;
- AliAODMCHeader* header =
- static_cast<AliAODMCHeader*>(fAOD->FindListObject(AliAODMCHeader::
- StdBranchName()));
- if (!header) return cent;
- b = header->GetImpactParameter();
-
+ if (!fAODMCHeader) return cent;
+ Double_t b = fAODMCHeader->GetImpactParameter();
cent = fImpactParToCent->Eval(b);
return cent;
}
//_____________________________________________________________________
-void AliForwardMCFlowTaskQC::PrintFlowSetup() const
-{
- //
- // Print the setup of the flow task
- //
- Printf("AliForwardMCFlowTaskQC::Print");
- Printf("Number of bins in vertex axis:\t%d", fVtxAxis->GetNbins());
- Printf("Range of vertex axis :\t[%3.1f,%3.1f]",
- fVtxAxis->GetXmin(), fVtxAxis->GetXmax());
- printf("Doing flow analysis for :\t");
- for (Int_t n = 0; n < fV.GetSize(); n++) printf("v%d ", fV.At(n));
- printf("\n");
- Printf("Satellite vertex flag :\t%s", ((fFlowFlags & kSatVtx) ? "true" : "false"));
- Printf("Symmetrize ref. flow wrt eta = 0:\t%s", ((fFlowFlags & kSymEta) ? "true" : "false"));
- Printf("Use an eta-gap for ref. flow :\t%s", ((fFlowFlags & kEtaGap) ? "true" : "false"));
- Printf("FMD sigma cut: :\t%f", fFMDCut);
- Printf("SPD sigma cut: :\t%f", fSPDCut);
- if ((fFlowFlags & kEtaGap))
- Printf("Eta gap: :\t%f", fEtaGap);
-}
-//_____________________________________________________________________
//
//
// EOF
-