[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / AliForwardCorrectionManager.cxx

#include "AliForwardCorrectionManager.h"
#include "AliForwardUtil.h"
#include <TString.h>
#include <AliLog.h>
#include <TFile.h>
#include <TSystem.h>

    
//____________________________________________________________________
AliForwardCorrectionManager* AliForwardCorrectionManager::fgInstance = 0;
const char* AliForwardCorrectionManager::fgkSecondaryMapSkel = "secondary";
const char* AliForwardCorrectionManager::fgkDoubleHitSkel    = "doublehit";
const char* AliForwardCorrectionManager::fgkELossFitsSkel    = "elossfits";
const char* AliForwardCorrectionManager::fgkVertexBiasSkel   = "vertexbias";
const char* AliForwardCorrectionManager::fgkMergingEffSkel   = "merging";

#define PREFIX "$(ALICE_ROOT)/PWG2/FORWARD/corrections/"

//____________________________________________________________________
AliForwardCorrectionManager& AliForwardCorrectionManager::Instance()
{
  if (!fgInstance) fgInstance= new AliForwardCorrectionManager;
  return *fgInstance;
}

//____________________________________________________________________
AliForwardCorrectionManager::AliForwardCorrectionManager()
  : TObject(), 
    fInit(kFALSE),
    fSys(0),
    fSNN(0),
    fField(999),
    fELossFitsPath(PREFIX "ELossFits"),
    fMergingEffPath(PREFIX "MergingEfficiency"), 
    fSecondaryMapPath(PREFIX "SecondaryMap"),
    fDoubleHitPath(PREFIX "DoubleHit"),
    fVertexBiasPath(PREFIX "VertexBias"),
    fELossFit(0),
    fSecondaryMap(0),
    fDoubleHit(0),
    fVertexBias(0),
    fMergingEfficiency(0)
{
}
//____________________________________________________________________
AliForwardCorrectionManager::AliForwardCorrectionManager(const AliForwardCorrectionManager& o)
  : TObject(o),
    fInit(o.fInit),
    fSys(o.fSys),
    fSNN(o.fSNN),
    fField(o.fField),
    fELossFitsPath(o.fELossFitsPath),
    fMergingEffPath(o.fMergingEffPath), 
    fSecondaryMapPath(o.fSecondaryMapPath),
    fDoubleHitPath(o.fDoubleHitPath),
    fVertexBiasPath(o.fVertexBiasPath),
    fELossFit(o.fELossFit),
    fSecondaryMap(o.fSecondaryMap),
    fDoubleHit(o.fDoubleHit),
    fVertexBias(o.fVertexBias),
    fMergingEfficiency(o.fMergingEfficiency)

{
}
//____________________________________________________________________
AliForwardCorrectionManager&
AliForwardCorrectionManager::operator=(const AliForwardCorrectionManager& o)
{
  fInit             = o.fInit;
  fSys              = o.fSys;
  fSNN              = o.fSNN;
  fField            = o.fField;
  fELossFitsPath    = o.fELossFitsPath;
  fMergingEffPath   = o.fMergingEffPath;
  fSecondaryMapPath = o.fSecondaryMapPath;
  fDoubleHitPath    = o.fDoubleHitPath;
  fVertexBiasPath   = o.fVertexBiasPath;
  fELossFit         = o.fELossFit;
  fSecondaryMap     = o.fSecondaryMap;
  fDoubleHit        = o.fDoubleHit;
  fVertexBias       = o.fVertexBias;
  fMergingEfficiency= o.fMergingEfficiency;
  return *this;
}

//____________________________________________________________________
Bool_t
AliForwardCorrectionManager::Init(const char* cms, 
				  Float_t     sNN, 
				  Float_t     field,
				  Bool_t      mc,
				  UInt_t      what,
				  Bool_t      force)
{
  UShort_t col = AliForwardUtil::ParseCollisionSystem(cms);
  return Init(col, 
	      AliForwardUtil::ParseCenterOfMassEnergy(col, sNN),
	      AliForwardUtil::ParseMagneticField(field), 
	      mc, what, force);
}

//____________________________________________________________________
Bool_t
AliForwardCorrectionManager::Init(UShort_t cms, 
				  UShort_t sNN, 
				  Short_t  field,
				  Bool_t   mc,
				  UInt_t   what,
				  Bool_t   force)
{
  if (force) fInit = kFALSE;
  if (fInit) return kTRUE;

  Bool_t ret = kTRUE;
  if (fSys == cms && TMath::Abs(fSNN - sNN) < 10 && fField == field) { 
    // We're already initialised for these settings - do nothing and return
    fInit = kTRUE;
    return ret;
  }
  // Set cached parameters 
  fSys   = cms;
  fSNN   = sNN;
  fField = field;
	       
  // Read secondary map if requested 
  if (what & kSecondaryMap) {
    if (!ReadSecondaryMap(cms, sNN, field)) {
      AliWarning(Form("Failed to read in secondary map for "
		      "cms=%d, sNN=%dGeV, field=%dkG", cms, sNN, field));
      ret = kFALSE;
    }
  }
  // Read double hit if requested 
  if (what & kDoubleHit) {
    if (!ReadDoubleHit(cms, sNN, field)) {
      AliWarning(Form("Failed to read in double hit correction for "
		      "cms=%d, sNN=%dGeV, field=%dkG", cms, sNN, field));
      ret = kFALSE;
    }
  }
  // Read energy loss fits if requested 
  if (what & kELossFits) {
    if (!ReadELossFits(cms, sNN, field, mc)) {
      AliWarning(Form("Failed to read in energy loss fits for "
		      "cms=%d, sNN=%dGeV, field=%dkG, %s", 
		      cms, sNN, field, mc ? "MC" : "real"));
      ret = kFALSE;
    }
  }
  // Read event selection efficiencies if requested 
  if (what & kVertexBias) {
    if (!ReadVertexBias(cms, sNN, field)) {
      AliWarning(Form("Failed to read in event selection efficiency for "
		      "cms=%d, sNN=%dGeV, field=%dkG", cms, sNN, field));
      ret = kFALSE;
    }
  }
  // Read merging efficiencies if requested 
  if (what & kMergingEfficiency) {
    if (!ReadMergingEfficiency(cms, sNN, field)) {
      AliWarning(Form("Failed to read in hit merging efficiency for "
		      "cms=%d, sNN=%dGeV, field=%dkG", 
		      cms, sNN, field));
      ret = kFALSE;
    }
  }
  fInit = kTRUE;
  return ret;
}

//____________________________________________________________________
TString 
AliForwardCorrectionManager::GetFileName(ECorrection what, 
					 UShort_t    sys, 
					 UShort_t    sNN,
					 Short_t     field,
					 Bool_t      mc) const
{
  TString fname = "";
  fname = GetObjectName(what);
  fname.Append(Form("_%s_%04dGeV_%c%1dkG_%s.root", 
		    AliForwardUtil::CollisionSystemString(sys), 
		    sNN, (field < 0 ? 'm' : 'p'), TMath::Abs(field), 
		    (mc ? "MC" : "real")));
  return fname;
}
//____________________________________________________________________
TString
AliForwardCorrectionManager::GetFileName(ECorrection what) const
{
  if (!fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return "";
  }
  return GetFileName(what, fSys, fSNN, fField, false);
}

//____________________________________________________________________
const Char_t*
AliForwardCorrectionManager::GetFileDir(ECorrection what) const
{
  if      (what & kSecondaryMap)        return fSecondaryMapPath;
  else if (what & kDoubleHit)           return fDoubleHitPath;
  else if (what & kELossFits)           return fELossFitsPath;
  else if (what & kVertexBias)          return fVertexBiasPath;
  else if (what & kMergingEfficiency)   return fMergingEffPath;

  AliWarning(Form("Unknown correction: %d", what));
  return 0;
}

//____________________________________________________________________
TString 
AliForwardCorrectionManager::GetFilePath(ECorrection what, 
					 UShort_t    sys, 
					 UShort_t    sNN,
					 Short_t     field,
					 Bool_t      mc) const
{
  TString path = "";
  const Char_t* dir = GetFileDir(what);
  if (!dir) return path;
  
  TString fname(GetFileName(what, sys, sNN, field, mc));
  if (fname.IsNull()) return path;

  path = gSystem->ConcatFileName(gSystem->ExpandPathName(dir), fname);
  
  return path;
}
//____________________________________________________________________
TString
AliForwardCorrectionManager::GetFilePath(ECorrection what) const
{
  if (!fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return "";
  }
  return GetFilePath(what, fSys, fSNN, fField, false);
}

//____________________________________________________________________
TFile*
AliForwardCorrectionManager::GetFile(ECorrection what, 
				     UShort_t    sys, 
				     UShort_t    sNN, 
				     Short_t     field, 
				     Bool_t      mc, 
				     Bool_t      rw, 
				     Bool_t      newfile) const
{
  TString path = GetFilePath(what, sys, sNN, field, mc);
  if (path.IsNull()) return 0;
  
  TString opt;
  if (newfile) opt="RECREATE";
  else {
    if (gSystem->AccessPathName(path.Data(), 
				(rw ? kWritePermission : kReadPermission))) {
      AliWarning(Form("file %s cannot be found or insufficient permissions", 
		      path.Data()));
      return 0;
    }
    opt=(rw ? "UPDATE" : "READ");
  }
  TFile* file = TFile::Open(path.Data(), opt.Data());
  if (!file) { 
    AliWarning(Form("file %s cannot be opened in mode %s", 
		    path.Data(), opt.Data()));
    return 0;
  }
  return file;
}
//____________________________________________________________________
TFile*
AliForwardCorrectionManager::GetFile(ECorrection what) const
{
  if (!fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return 0;
  }
  return GetFile(what, fSys, fSNN, fField, false);
}

//____________________________________________________________________
const Char_t*
AliForwardCorrectionManager::GetObjectName(ECorrection what) const
{
  if      (what & kSecondaryMap)       return fgkSecondaryMapSkel;
  else if (what & kDoubleHit)          return fgkDoubleHitSkel;
  else if (what & kELossFits)          return fgkELossFitsSkel;
  else if (what & kVertexBias)         return fgkVertexBiasSkel;
  else if (what & kMergingEfficiency)  return fgkMergingEffSkel;
  return 0;
}

//____________________________________________________________________
TObject*
AliForwardCorrectionManager::CheckObject(TFile* file, ECorrection what) const
{
  TObject* o = file->Get(GetObjectName(what));
  if (!o) { 
    AliWarning(Form("Object %s not found in %s", 
		    GetObjectName(what), file->GetName()));
    file->Close();
    return 0;
  }
  return o;
}
  
//____________________________________________________________________
TObject*
AliForwardCorrectionManager::GetObject(ECorrection what, 
				       UShort_t    sys, 
				       UShort_t    sNN, 
				       Short_t     field,
				       Bool_t      mc) const
{
  TFile* file = GetFile(what, sys, sNN, field, mc, false, false);
  if (!file) return 0;
  
  return CheckObject(file, what);
}
//____________________________________________________________________
TObject*
AliForwardCorrectionManager::GetObject(ECorrection what) const
{
  if (!fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return 0;
  }
  return GetObject(what, fSys, fSNN, fField, false);
}


//____________________________________________________________________
Bool_t 
AliForwardCorrectionManager::ReadSecondaryMap(UShort_t sys, UShort_t sNN, 
					      Short_t field)
{
  if (fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return kFALSE;
  }

  TObject* o = GetObject(kSecondaryMap, sys, sNN, field, false);
  if (!o) return kFALSE;

  fSecondaryMap = dynamic_cast<AliFMDCorrSecondaryMap*>(o);
  if (!fSecondaryMap) {
    AliWarning(Form("Object %s (%p) is not an AliFMDCorrSecondaryMap object, "
		    "but %s", fgkSecondaryMapSkel, o, o->ClassName())); 
    return kFALSE;
  }

  // file->Close();
  return kTRUE;
}
//____________________________________________________________________
Bool_t 
AliForwardCorrectionManager::ReadDoubleHit(UShort_t sys, UShort_t sNN, 
					   Short_t field)
{
  if (fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return kFALSE;
  }

  TObject* o = GetObject(kDoubleHit, sys, sNN, field, false);
  if (!o) return kFALSE;

  fDoubleHit = dynamic_cast<AliFMDCorrDoubleHit*>(o);
  if (!fDoubleHit) {
    AliWarning(Form("Object %s (%p) is not an AliFMDCorrDoubleHit object, "
		    "but %s", fgkDoubleHitSkel, o, o->ClassName())); 
    return kFALSE;
  }

  // file->Close();
  return kTRUE;
}

//____________________________________________________________________
Bool_t 
AliForwardCorrectionManager::ReadELossFits(UShort_t sys, UShort_t sNN, 
					   Short_t field, Bool_t mc)
{
  if (fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return kFALSE;
  }

  TObject* o = GetObject(kELossFits, sys, sNN, field, mc);
  if (!o) return kFALSE;

  fELossFit = dynamic_cast<AliFMDCorrELossFit*>(o);
  if (!fELossFit) {
    AliWarning(Form("Object %s (%p) is not an AliFMDCorrELossFit object, "
		    "but %s", fgkELossFitsSkel, o, o->ClassName()));
    return kFALSE;
  }

  // file->Close();
  return kTRUE;
}

//____________________________________________________________________
Bool_t 
AliForwardCorrectionManager::ReadVertexBias(UShort_t sys, 
					    UShort_t sNN, 
					    Short_t field)
{
  if (fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return kFALSE;
  }

  TObject* o = GetObject(kVertexBias, sys, sNN, field, false);
  if (!o) return kFALSE;

  fVertexBias = dynamic_cast<AliFMDCorrVertexBias*>(o);
  if (!fVertexBias) {
    AliWarning(Form("Object %s (%p) is not an AliFMDCorrVertexBias object, "
		    "but %s", fgkVertexBiasSkel, o, o->ClassName()));
    return kFALSE;
  }

  // file->Close();
  return kTRUE;
}

//____________________________________________________________________
Bool_t 
AliForwardCorrectionManager::ReadMergingEfficiency(UShort_t sys, 
						   UShort_t sNN, 
						   Short_t field)
{
  if (fInit) { 
    AliWarning("Corrections manager initialised, do a forced Init(...)");
    return kFALSE;
  }

  TObject* o = GetObject(kMergingEfficiency, sys, sNN, field, false);
  if (!o) return kFALSE;

  fMergingEfficiency = dynamic_cast<AliFMDCorrMergingEfficiency*>(o);
  if (!fMergingEfficiency) {
    AliWarning(Form("Object %s (%p) is not an AliFMDCorrMergingEfficiency "
		    "object, but %s", fgkMergingEffSkel, o, o->ClassName()));
    return kFALSE;
  }

  // file->Close();
  return kTRUE;
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
0bd4b00f	1	#include "AliForwardCorrectionManager.h"
	2	#include "AliForwardUtil.h"
	3	#include <TString.h>
	4	#include <AliLog.h>
	5	#include <TFile.h>
	6	#include <TSystem.h>
	7
	8
	9	//____________________________________________________________________
	10	AliForwardCorrectionManager* AliForwardCorrectionManager::fgInstance = 0;
	11	const char* AliForwardCorrectionManager::fgkSecondaryMapSkel = "secondary";
	12	const char* AliForwardCorrectionManager::fgkDoubleHitSkel = "doublehit";
	13	const char* AliForwardCorrectionManager::fgkELossFitsSkel = "elossfits";
	14	const char* AliForwardCorrectionManager::fgkVertexBiasSkel = "vertexbias";
	15	const char* AliForwardCorrectionManager::fgkMergingEffSkel = "merging";
	16
	17	#define PREFIX "$(ALICE_ROOT)/PWG2/FORWARD/corrections/"
	18
	19	//____________________________________________________________________
	20	AliForwardCorrectionManager& AliForwardCorrectionManager::Instance()
	21	{
	22	if (!fgInstance) fgInstance= new AliForwardCorrectionManager;
	23	return *fgInstance;
	24	}
	25
	26	//____________________________________________________________________
	27	AliForwardCorrectionManager::AliForwardCorrectionManager()
	28	: TObject(),
	29	fInit(kFALSE),
	30	fSys(0),
	31	fSNN(0),
	32	fField(999),
	33	fELossFitsPath(PREFIX "ELossFits"),
	34	fMergingEffPath(PREFIX "MergingEfficiency"),
	35	fSecondaryMapPath(PREFIX "SecondaryMap"),
	36	fDoubleHitPath(PREFIX "DoubleHit"),
	37	fVertexBiasPath(PREFIX "VertexBias"),
	38	fELossFit(0),
	39	fSecondaryMap(0),
	40	fDoubleHit(0),
	41	fVertexBias(0),
	42	fMergingEfficiency(0)
	43	{
	44	}
	45	//____________________________________________________________________
	46	AliForwardCorrectionManager::AliForwardCorrectionManager(const AliForwardCorrectionManager& o)
	47	: TObject(o),
	48	fInit(o.fInit),
	49	fSys(o.fSys),
	50	fSNN(o.fSNN),
	51	fField(o.fField),
	52	fELossFitsPath(o.fELossFitsPath),
	53	fMergingEffPath(o.fMergingEffPath),
	54	fSecondaryMapPath(o.fSecondaryMapPath),
	55	fDoubleHitPath(o.fDoubleHitPath),
	56	fVertexBiasPath(o.fVertexBiasPath),
	57	fELossFit(o.fELossFit),
	58	fSecondaryMap(o.fSecondaryMap),
	59	fDoubleHit(o.fDoubleHit),
	60	fVertexBias(o.fVertexBias),
	61	fMergingEfficiency(o.fMergingEfficiency)
	62
	63	{
	64	}
65	//____________________________________________________________________
66	AliForwardCorrectionManager&
67	AliForwardCorrectionManager::operator=(const AliForwardCorrectionManager& o)
68	{
69	fInit = o.fInit;
70	fSys = o.fSys;
71	fSNN = o.fSNN;
72	fField = o.fField;
73	fELossFitsPath = o.fELossFitsPath;
74	fMergingEffPath = o.fMergingEffPath;
75	fSecondaryMapPath = o.fSecondaryMapPath;
76	fDoubleHitPath = o.fDoubleHitPath;
77	fVertexBiasPath = o.fVertexBiasPath;
78	fELossFit = o.fELossFit;
79	fSecondaryMap = o.fSecondaryMap;
80	fDoubleHit = o.fDoubleHit;
81	fVertexBias = o.fVertexBias;
82	fMergingEfficiency= o.fMergingEfficiency;
83	return *this;
84	}
85
86	//____________________________________________________________________
87	Bool_t
88	AliForwardCorrectionManager::Init(const char* cms,
89	Float_t sNN,
90	Float_t field,
91	Bool_t mc,
92	UInt_t what,
93	Bool_t force)
94	{
95	UShort_t col = AliForwardUtil::ParseCollisionSystem(cms);
96	return Init(col,
97	AliForwardUtil::ParseCenterOfMassEnergy(col, sNN),
98	AliForwardUtil::ParseMagneticField(field),
99	mc, what, force);
100	}
101
102	//____________________________________________________________________
103	Bool_t
104	AliForwardCorrectionManager::Init(UShort_t cms,
105	UShort_t sNN,
106	Short_t field,
107	Bool_t mc,
108	UInt_t what,
109	Bool_t force)
110	{
111	if (force) fInit = kFALSE;
112	if (fInit) return kTRUE;
113
114	Bool_t ret = kTRUE;
115	if (fSys == cms && TMath::Abs(fSNN - sNN) < 10 && fField == field) {
116	// We're already initialised for these settings - do nothing and return
117	fInit = kTRUE;
118	return ret;
119	}
120	// Set cached parameters
121	fSys = cms;
122	fSNN = sNN;
123	fField = field;
124
125	// Read secondary map if requested
126	if (what & kSecondaryMap) {
127	if (!ReadSecondaryMap(cms, sNN, field)) {
128	AliWarning(Form("Failed to read in secondary map for "
129	"cms=%d, sNN=%dGeV, field=%dkG", cms, sNN, field));
130	ret = kFALSE;
131	}
132	}
133	// Read double hit if requested
134	if (what & kDoubleHit) {
135	if (!ReadDoubleHit(cms, sNN, field)) {
136	AliWarning(Form("Failed to read in double hit correction for "
137	"cms=%d, sNN=%dGeV, field=%dkG", cms, sNN, field));
138	ret = kFALSE;
139	}
140	}
141	// Read energy loss fits if requested
142	if (what & kELossFits) {
143	if (!ReadELossFits(cms, sNN, field, mc)) {
144	AliWarning(Form("Failed to read in energy loss fits for "
145	"cms=%d, sNN=%dGeV, field=%dkG, %s",
146	cms, sNN, field, mc ? "MC" : "real"));
147	ret = kFALSE;
148	}
149	}
150	// Read event selection efficiencies if requested
151	if (what & kVertexBias) {
152	if (!ReadVertexBias(cms, sNN, field)) {
153	AliWarning(Form("Failed to read in event selection efficiency for "
154	"cms=%d, sNN=%dGeV, field=%dkG", cms, sNN, field));
155	ret = kFALSE;
156	}
157	}
158	// Read merging efficiencies if requested
159	if (what & kMergingEfficiency) {
160	if (!ReadMergingEfficiency(cms, sNN, field)) {
161	AliWarning(Form("Failed to read in hit merging efficiency for "
162	"cms=%d, sNN=%dGeV, field=%dkG",
163	cms, sNN, field));
164	ret = kFALSE;
165	}
166	}
167	fInit = kTRUE;
168	return ret;
169	}
170
171	//____________________________________________________________________
172	TString
173	AliForwardCorrectionManager::GetFileName(ECorrection what,
174	UShort_t sys,
175	UShort_t sNN,
176	Short_t field,
177	Bool_t mc) const
178	{
179	TString fname = "";
180	fname = GetObjectName(what);
181	fname.Append(Form("_%s_%04dGeV_%c%1dkG_%s.root",
182	AliForwardUtil::CollisionSystemString(sys),
183	sNN, (field < 0 ? 'm' : 'p'), TMath::Abs(field),
184	(mc ? "MC" : "real")));
185	return fname;
186	}
187	//____________________________________________________________________
188	TString
189	AliForwardCorrectionManager::GetFileName(ECorrection what) const
190	{
191	if (!fInit) {
192	AliWarning("Corrections manager initialised, do a forced Init(...)");
193	return "";
194	}
195	return GetFileName(what, fSys, fSNN, fField, false);
196	}
197
198	//____________________________________________________________________
199	const Char_t*
200	AliForwardCorrectionManager::GetFileDir(ECorrection what) const
201	{
202	if (what & kSecondaryMap) return fSecondaryMapPath;
203	else if (what & kDoubleHit) return fDoubleHitPath;
204	else if (what & kELossFits) return fELossFitsPath;
205	else if (what & kVertexBias) return fVertexBiasPath;
206	else if (what & kMergingEfficiency) return fMergingEffPath;
207
208	AliWarning(Form("Unknown correction: %d", what));
209	return 0;
210	}
211
212	//____________________________________________________________________
213	TString
214	AliForwardCorrectionManager::GetFilePath(ECorrection what,
215	UShort_t sys,
216	UShort_t sNN,
217	Short_t field,
218	Bool_t mc) const
219	{
220	TString path = "";
221	const Char_t* dir = GetFileDir(what);
222	if (!dir) return path;
223
224	TString fname(GetFileName(what, sys, sNN, field, mc));
225	if (fname.IsNull()) return path;
226
227	path = gSystem->ConcatFileName(gSystem->ExpandPathName(dir), fname);
228
229	return path;
230	}
231	//____________________________________________________________________
232	TString
233	AliForwardCorrectionManager::GetFilePath(ECorrection what) const
234	{
235	if (!fInit) {
236	AliWarning("Corrections manager initialised, do a forced Init(...)");
237	return "";
238	}
239	return GetFilePath(what, fSys, fSNN, fField, false);
240	}
241
242	//____________________________________________________________________
243	TFile*
244	AliForwardCorrectionManager::GetFile(ECorrection what,
245	UShort_t sys,
246	UShort_t sNN,
247	Short_t field,
248	Bool_t mc,
249	Bool_t rw,
250	Bool_t newfile) const
251	{
252	TString path = GetFilePath(what, sys, sNN, field, mc);
253	if (path.IsNull()) return 0;
254
255	TString opt;
256	if (newfile) opt="RECREATE";
257	else {
258	if (gSystem->AccessPathName(path.Data(),
259	(rw ? kWritePermission : kReadPermission))) {
260	AliWarning(Form("file %s cannot be found or insufficient permissions",
261	path.Data()));
262	return 0;
263	}
264	opt=(rw ? "UPDATE" : "READ");
265	}
266	TFile* file = TFile::Open(path.Data(), opt.Data());
267	if (!file) {
268	AliWarning(Form("file %s cannot be opened in mode %s",
269	path.Data(), opt.Data()));
270	return 0;
271	}
272	return file;
273	}
274	//____________________________________________________________________
275	TFile*
276	AliForwardCorrectionManager::GetFile(ECorrection what) const
277	{
278	if (!fInit) {
279	AliWarning("Corrections manager initialised, do a forced Init(...)");
280	return 0;
281	}
282	return GetFile(what, fSys, fSNN, fField, false);
283	}
284
285	//____________________________________________________________________
286	const Char_t*
287	AliForwardCorrectionManager::GetObjectName(ECorrection what) const
288	{
289	if (what & kSecondaryMap) return fgkSecondaryMapSkel;
290	else if (what & kDoubleHit) return fgkDoubleHitSkel;
291	else if (what & kELossFits) return fgkELossFitsSkel;
292	else if (what & kVertexBias) return fgkVertexBiasSkel;
293	else if (what & kMergingEfficiency) return fgkMergingEffSkel;
294	return 0;
295	}
296
297	//____________________________________________________________________
298	TObject*
299	AliForwardCorrectionManager::CheckObject(TFile* file, ECorrection what) const
300	{
301	TObject* o = file->Get(GetObjectName(what));
302	if (!o) {
303	AliWarning(Form("Object %s not found in %s",
304	GetObjectName(what), file->GetName()));
305	file->Close();
306	return 0;
307	}
308	return o;
309	}
310
311	//____________________________________________________________________
312	TObject*
313	AliForwardCorrectionManager::GetObject(ECorrection what,
314	UShort_t sys,
315	UShort_t sNN,
316	Short_t field,
317	Bool_t mc) const
318	{
319	TFile* file = GetFile(what, sys, sNN, field, mc, false, false);
320	if (!file) return 0;
321
322	return CheckObject(file, what);
323	}
324	//____________________________________________________________________
325	TObject*
326	AliForwardCorrectionManager::GetObject(ECorrection what) const
327	{
328	if (!fInit) {
329	AliWarning("Corrections manager initialised, do a forced Init(...)");
330	return 0;
331	}
332	return GetObject(what, fSys, fSNN, fField, false);
333	}
334
335
336	//____________________________________________________________________
337	Bool_t
338	AliForwardCorrectionManager::ReadSecondaryMap(UShort_t sys, UShort_t sNN,
339	Short_t field)
340	{
341	if (fInit) {
342	AliWarning("Corrections manager initialised, do a forced Init(...)");
343	return kFALSE;
344	}
345
346	TObject* o = GetObject(kSecondaryMap, sys, sNN, field, false);
347	if (!o) return kFALSE;
348
349	fSecondaryMap = dynamic_cast<AliFMDCorrSecondaryMap*>(o);
350	if (!fSecondaryMap) {
351	AliWarning(Form("Object %s (%p) is not an AliFMDCorrSecondaryMap object, "
352	"but %s", fgkSecondaryMapSkel, o, o->ClassName()));
353	return kFALSE;
354	}
355
356	// file->Close();
357	return kTRUE;
358	}
359	//____________________________________________________________________
360	Bool_t
361	AliForwardCorrectionManager::ReadDoubleHit(UShort_t sys, UShort_t sNN,
362	Short_t field)
363	{
364	if (fInit) {
365	AliWarning("Corrections manager initialised, do a forced Init(...)");
366	return kFALSE;
367	}
368
369	TObject* o = GetObject(kDoubleHit, sys, sNN, field, false);
370	if (!o) return kFALSE;
371
372	fDoubleHit = dynamic_cast<AliFMDCorrDoubleHit*>(o);
373	if (!fDoubleHit) {
374	AliWarning(Form("Object %s (%p) is not an AliFMDCorrDoubleHit object, "
375	"but %s", fgkDoubleHitSkel, o, o->ClassName()));
376	return kFALSE;
377	}
378
379	// file->Close();
380	return kTRUE;
381	}
382
383	//____________________________________________________________________
384	Bool_t
385	AliForwardCorrectionManager::ReadELossFits(UShort_t sys, UShort_t sNN,
386	Short_t field, Bool_t mc)
387	{
388	if (fInit) {
389	AliWarning("Corrections manager initialised, do a forced Init(...)");
390	return kFALSE;
391	}
392
393	TObject* o = GetObject(kELossFits, sys, sNN, field, mc);
394	if (!o) return kFALSE;
395
396	fELossFit = dynamic_cast<AliFMDCorrELossFit*>(o);
397	if (!fELossFit) {
398	AliWarning(Form("Object %s (%p) is not an AliFMDCorrELossFit object, "
399	"but %s", fgkELossFitsSkel, o, o->ClassName()));
400	return kFALSE;
401	}
402
403	// file->Close();
404	return kTRUE;
405	}
406
407	//____________________________________________________________________
408	Bool_t
409	AliForwardCorrectionManager::ReadVertexBias(UShort_t sys,
410	UShort_t sNN,
411	Short_t field)
412	{
413	if (fInit) {
414	AliWarning("Corrections manager initialised, do a forced Init(...)");
415	return kFALSE;
416	}
417
418	TObject* o = GetObject(kVertexBias, sys, sNN, field, false);
419	if (!o) return kFALSE;
420
421	fVertexBias = dynamic_cast<AliFMDCorrVertexBias*>(o);
422	if (!fVertexBias) {
423	AliWarning(Form("Object %s (%p) is not an AliFMDCorrVertexBias object, "
424	"but %s", fgkVertexBiasSkel, o, o->ClassName()));
425	return kFALSE;
426	}
427
428	// file->Close();
429	return kTRUE;
430	}
431
432	//____________________________________________________________________
433	Bool_t
434	AliForwardCorrectionManager::ReadMergingEfficiency(UShort_t sys,
435	UShort_t sNN,
436	Short_t field)
437	{
438	if (fInit) {
439	AliWarning("Corrections manager initialised, do a forced Init(...)");
440	return kFALSE;
441	}
442
443	TObject* o = GetObject(kMergingEfficiency, sys, sNN, field, false);
444	if (!o) return kFALSE;
445
446	fMergingEfficiency = dynamic_cast<AliFMDCorrMergingEfficiency*>(o);
447	if (!fMergingEfficiency) {
448	AliWarning(Form("Object %s (%p) is not an AliFMDCorrMergingEfficiency "
449	"object, but %s", fgkMergingEffSkel, o, o->ClassName()));
450	return kFALSE;
451	}
452
453	// file->Close();
454	return kTRUE;
455	}
456
457	//____________________________________________________________________
458	//
459	// EOF
460	//