} else if (AlignResiduals==2) {
- // tracking errors ... PLUS ... module misalignment
+ // tracking errors ... PLUS ... chip misalignment
// itsRecoParam->SetClusterMisalErrorYBOn(0.0010,0.0030,0.0500,0.0500,0.0020,0.0020); // [cm]
// itsRecoParam->SetClusterMisalErrorZBOn(0.0050,0.0050,0.0050,0.0050,0.1000,0.1000);
- // the ITS modules are misalignment with small gaussian smearings with
+ // the ITS chips are misalignment with small gaussian smearings with
// sigmarphi ~ 8, 10, 10 micron in SPD, SDD, SSD
AddLayer((char*)"spd1", 3.9, 0.0114, TMath::Sqrt(0.0012*0.0012+0.0010*0.0010+0.0008*0.0008),
} else {
- // the ITS modules are misalignment with small gaussian smearings with
+ // the ITS chips are misalignment with small gaussian smearings with
// sigmarphi ~ 8, 10, 10 micron in SPD, SDD, SSD
// unknown in Z ????
} else if (AlignResiduals==2) {
- // tracking errors ... PLUS ... module misalignment
+ // tracking errors ... PLUS ... chip misalignment
// itsRecoParam->SetClusterMisalErrorYBOn(0.0010,0.0030,0.0500,0.0500,0.0020,0.0020); // [cm]
// itsRecoParam->SetClusterMisalErrorZBOn(0.0050,0.0050,0.0050,0.0050,0.1000,0.1000);
- // the ITS modules are misalignment with small gaussian smearings with
+ // the ITS chips are misalignment with small gaussian smearings with
// sigmarphi ~ 8, 10, 10 micron in SPD, SDD, SSD
AddLayer((char*)"spd1", 3.9, 0.0114, TMath::Sqrt(0.0012*0.0012+0.0010*0.0010+0.0008*0.0008),
} else {
- // the ITS modules are misalignment with small gaussian smearings with
+ // the ITS chips are misalignment with small gaussian smearings with
// sigmarphi ~ 8, 10, 10 micron in SPD, SDD, SSD
// unknown in Z ????
} else if (AlignResiduals==2) {
- // tracking errors ... PLUS ... module misalignment
+ // tracking errors ... PLUS ... chip misalignment
// itsRecoParam->SetClusterMisalErrorYBOn(0.0010,0.0030,0.0500,0.0500,0.0020,0.0020); // [cm]
// itsRecoParam->SetClusterMisalErrorZBOn(0.0050,0.0050,0.0050,0.0050,0.1000,0.1000);
- // the ITS modules are misalignment with small gaussian smearings with
+ // the ITS chips are misalignment with small gaussian smearings with
// sigmarphi ~ 8, 10, 10 micron in SPD, SDD, SSD
AddLayer((char*)"spd1_its", 3.9, 0.0114, 2.48e-01, TMath::Sqrt(0.0012*0.0012+0.0010*0.0010+0.0008*0.0008),
} else {
- // the ITS modules are misalignment with small gaussian smearings with
+ // the ITS chips are misalignment with small gaussian smearings with
// sigmarphi ~ 8, 10, 10 micron in SPD, SDD, SSD
// unknown in Z ????
new( (*deltas)[idel++] ) AliAlignObjParams(sname.Data(),dummyVID,
dx,dy,dz,dtht,dpsi,dphi,kTRUE);
//
- for (int isn=0;isn<gm0->GetNChipsPerModule(ilr);isn++) {
+ for (int isn=0;isn<gm0->GetNChipsPerStave(ilr);isn++) {
dx = sgXMod*gRandom->Gaus();
dy = sgYMod*gRandom->Gaus();
dz = sgZMod*gRandom->Gaus();
dpsi = sgPsiMod*gRandom->Gaus();
dphi = sgPhiMod*gRandom->Gaus();
int mid = gm0->GetChipIndex(ilr,ild,isn);
- sname = gm0->GetSymName(mid);
+ sname = gm0->ComposeSymNameChip(ilr,ild,-1,-1,isn);
new( (*deltas)[idel++] ) AliAlignObjParams(sname.Data(),gm0->ChipVolUID(mid),
dx,dy,dz,dtht,dpsi,dphi,kTRUE);
}
#include "AliITSReconstructor.h"
#include "AliITSupgrade.h"
#include "AliITSUpgradeReconstructor.h" //class header
-#include "AliITSDetTypeRec.h"
+#include "AliITSChipTypeRec.h"
#include "AliITS.h" //Reconstruct()
#include "AliESDEvent.h" //FillEsd()
#include "AliRawReader.h" //Reconstruct() for raw digits
fCDBUri(),
fQARefUri(),
fSpecCDBUri(),
+ fCheckRecoCDBvsSimuCDB(),
fInitCDBCalled(kFALSE),
fCDBSnapshotMode(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
fQAWriteExpert[iDet] = kFALSE ;
}
fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
-
+ //
+ AddCheckRecoCDBvsSimuCDB("TPC/Calib/RecoParam"); // check for similarity in the sim and rec
+ //
AliPID pid;
}
fCDBUri(rec.fCDBUri),
fQARefUri(rec.fQARefUri),
fSpecCDBUri(),
+ fCheckRecoCDBvsSimuCDB(),
fInitCDBCalled(rec.fInitCDBCalled),
fCDBSnapshotMode(rec.fCDBSnapshotMode),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
}
+ for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
+ if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
+ }
+
for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
}
fCDBUri = "";
fQARefUri = rec.fQARefUri;
fSpecCDBUri.Delete();
+ fCheckRecoCDBvsSimuCDB.Delete();
+ //
+ for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
+ if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
+ }
+ //
fInitCDBCalled = rec.fInitCDBCalled;
fCDBSnapshotMode = rec.fCDBSnapshotMode;
fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
delete fAlignObjArray;
}
fSpecCDBUri.Delete();
-
+ fCheckRecoCDBvsSimuCDB.Delete();
AliCodeTimer::Instance()->Print();
}
AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
}
+
//_____________________________________________________________________________
void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
// Store a detector-specific CDB storage location
}
+//_____________________________________________________________________________
+void AliReconstruction::AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment)
+{
+ // require the cdb item to be the same in the rec as in the sim
+ // Activate it later within the Run() method
+ TString newent = cdbpath;
+ if (newent.IsNull()) return;
+ TIter nextit(&fCheckRecoCDBvsSimuCDB);
+ TNamed* cdbent=0;
+ while ((cdbent=(TNamed*)nextit())) {
+ TString str = cdbent->GetName();
+ if (str==newent) {
+ AliInfo(Form("%s is already in the list to check",cdbpath));
+ return;
+ }
+ }
+ fCheckRecoCDBvsSimuCDB.AddLast(new TNamed(cdbpath,comment));
+ //
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::RemCheckRecoCDBvsSimuCDB(const char* cdbpath)
+{
+ // require the cdb item to be the same in the rec as in the sim
+ // Activate it later within the Run() method
+ TString newent = cdbpath;
+ if (newent.IsNull()) return;
+ TIter nextit(&fCheckRecoCDBvsSimuCDB);
+ TNamed* cdbent=0;
+ while ((cdbent=(TNamed*)nextit())) {
+ TString str = cdbent->GetName();
+ if (str==newent) {
+ AliInfo(Form("Removing %s from the list to check",cdbpath));
+ delete fCheckRecoCDBvsSimuCDB.Remove(cdbent);
+ fCheckRecoCDBvsSimuCDB.Compress();
+ return;
+ }
+ }
+ AliInfo(Form("%s is not in the list to check",cdbpath));
+ //
+}
+
//_____________________________________________________________________________
Bool_t AliReconstruction::SetRunNumberFromData()
{
}
AliSysInfo::AddStamp("LoadLoader");
+ CheckRecoCDBvsSimuCDB();
+
ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
// get trackers
return ( (eventId < fRunLoader->GetNumberOfEvents()) ||
(fRawReader && fRawReader->NextEvent()) );
}
+
+//_________________________________________________________________
+void AliReconstruction::CheckRecoCDBvsSimuCDB()
+{
+ // if some CDB entries must be the same in the simulation
+ // and reconstruction, check here
+ int nent = fCheckRecoCDBvsSimuCDB.GetEntriesFast();
+ AliInfo(Form("Check %d entries for matching between sim and rec",nent));
+ //
+ // get simulation CDB
+ fRunLoader->CdGAFile();
+ TMap* cdbMapSim = (TMap*)gDirectory->Get("cdbMap");
+ TList* cdbListSim = (TList*)gDirectory->Get("cdbList");
+ if (!(cdbMapSim && cdbListSim)) {
+ AliInfo(Form("No CDBMap/List found in %s, nothing to check",fGAliceFileName.Data()));
+ return;
+ }
+ // read the requested objects to make sure they will appear in the reco list
+ for (Int_t i=0;i<nent;i++) {
+ TNamed* cdbent = (TNamed*) fCheckRecoCDBvsSimuCDB[i];
+ if (!cdbent) continue;
+ AliCDBManager::Instance()->Get(cdbent->GetName());
+ }
+ // get default path for simulation
+ TPair* pair;
+ TObjString* stro;
+ pair = (TPair*)cdbMapSim->FindObject("default");
+ if (!pair) {AliFatal("Did not find default storage used for simulations"); return;}
+ TString defSimStore = ((TObjString*)pair->Value())->GetString();
+ RectifyCDBurl(defSimStore);
+ //
+ // get reconstruction CDB
+ const TMap *cdbMapRec = AliCDBManager::Instance()->GetStorageMap();
+ const TList *cdbListRec = AliCDBManager::Instance()->GetRetrievedIds();
+ //
+ // get default path for reconstruction
+ pair = (TPair*)cdbMapRec->FindObject("default");
+ if (!pair) {AliFatal("Did not find default storage used for reconstruction"); return;}
+ TString defRecStore = ((TObjString*)pair->Value())->GetString();
+ RectifyCDBurl(defRecStore);
+ //
+ for (Int_t i=0;i<nent;i++) {
+ TNamed* cdbent = (TNamed*) fCheckRecoCDBvsSimuCDB[i];
+ if (!cdbent) continue;
+ //
+ AliInfo(Form("#%d Checking %s",i,cdbent->GetName()));
+ //
+ // check in the simuCDB special params
+ pair = (TPair*)cdbMapSim->FindObject(cdbent->GetName());
+ TString idSimD = "";
+ TString idSimS = "";
+ if (pair) { // specific path is used
+ idSimS = ((TObjString*)pair->Value())->GetString();
+ RectifyCDBurl(idSimS);
+ }
+ else { // check in default storage list
+ TIter nextSim(cdbListSim);
+ while ((stro=(TObjString*)nextSim())) {
+ if (stro->GetString().Contains(cdbent->GetName())) {
+ idSimD = stro->GetString();
+ break;
+ }
+ }
+ }
+ //
+ // check in the recoCDB special params
+ pair = (TPair*)cdbMapRec->FindObject(cdbent->GetName());
+ TString idRecD = "";
+ TString idRecS = "";
+ if (pair) { // specific path is used
+ idRecS = ((TObjString*)pair->Value())->GetString();
+ RectifyCDBurl(idRecS);
+ }
+ else { // check in default storage list
+ TIter nextRec(cdbListRec);
+ while ((stro=(TObjString*)nextRec())) {
+ if (stro->GetString().Contains(cdbent->GetName())) {
+ idRecD = stro->GetString();
+ break;
+ }
+ }
+ }
+ //-----------------------------
+ Bool_t ok = kTRUE;
+ if (!idSimD.IsNull()) { // simulation used object from default storage
+ AliInfo(Form("Simulation used default storage %s\nentry %s",defSimStore.Data(),idSimD.Data()));
+ if (!idRecD.IsNull()) { // reco also
+ AliInfo(Form("Reconstruction used default storage %s\nentry %s",defRecStore.Data(),idRecD.Data()));
+ if ( (idSimD!=idRecD) || (defSimStore!=defRecStore) ) ok = kFALSE;
+ }
+ else if (!idRecS.IsNull()) { // reco used specific storage, strict check of version is not possible
+ AliInfo(Form("Reconstruction used specific storage %s",idRecS.Data()));
+ if (defSimStore!=idRecS) ok = kFALSE;
+ }
+ else {
+ AliInfo("Did not find object used in reconstruction");
+ ok = kFALSE;
+ }
+ }
+ else if (!idSimS.IsNull()) { // simulation used object from specific storage
+ AliInfo(Form("Simulation used specific storage %s",idSimS.Data()));
+ if (!idRecS.IsNull()) { // reco also
+ AliInfo(Form("Reconstruction used specific storage %s",idRecS.Data()));
+ if (idSimS!=idRecS) ok = kFALSE;
+ }
+ else if (!idRecD.IsNull()) {
+ AliInfo(Form("Reconstruction used default storage %s\nentry",idRecD.Data()));
+ if (idSimS!=defRecStore) ok = kFALSE;
+ }
+ else {
+ AliInfo("Did not find object used in reconstruction");
+ ok = kFALSE;
+ }
+ }
+ else {
+ AliInfo("Did not find object used in simulation");
+ ok = kFALSE;
+ }
+ if (!ok) AliFatal("Different objects were used in sim and rec");
+ }
+ //
+}
+
+//_________________________________________________________
+void AliReconstruction::RectifyCDBurl(TString& url)
+{
+ // TBD RS
+ // remove everything but the url
+ TString sbs;
+ if (!(sbs=url("\\?User=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
+ if (!(sbs=url("\\?DBFolder=[^?]*")).IsNull()) url.ReplaceAll("?DB","");
+ if (!(sbs=url("\\?SE=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
+ if (!(sbs=url("\\?CacheFolder=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
+ if (!(sbs=url("\\?OperateDisconnected=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
+ if (!(sbs=url("\\?CacheSize=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
+ if (!(sbs=url("\\?CleanupInterval=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
+ url.ToLower();
+ //
+}
void SetDefaultStorage(const char* uri);
void SetSpecificStorage(const char* calibType, const char* uri);
void SetCDBSnapshotMode(const char* snapshotFileName);
-
+ void AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment="");
+ void RemCheckRecoCDBvsSimuCDB(const char* cdbpath);
+ void ResetCheckRecoCDBvsSimuCDB() {fCheckRecoCDBvsSimuCDB.Delete();}
+ void RectifyCDBurl(TString& url);
+ const TObjArray* GetCheckRecoCDBvsSimuCDB() const {return &fCheckRecoCDBvsSimuCDB;}
+ void CheckRecoCDBvsSimuCDB();
Bool_t MisalignGeometry(const TString& detectors);
void SetAlignObjArray(TObjArray *array)
TString fCDBUri; //! Uri of the default CDB storage
TString fQARefUri; //! Uri of the default QA reference storage
TObjArray fSpecCDBUri; //! Array with detector specific CDB storages
+ TObjArray fCheckRecoCDBvsSimuCDB; // Array for CDB items which must be the same in the sim and rec
Bool_t fInitCDBCalled; //! flag to check if CDB storages are already initialized
Bool_t fCDBSnapshotMode; //! flag true if we are setting the CDB Manager in snapshot mode
Bool_t fSetRunNumberFromDataCalled; //! flag to check if run number is already loaded from run loader
Int_t fMaxVMEM; // max VMEM memory, MB
static const char* fgkStopEvFName; // filename for stop.event stamp
//
- ClassDef(AliReconstruction, 48) // class for running the reconstruction
+ ClassDef(AliReconstruction, 49) // class for running the reconstruction
};
#endif
AliRunLoader::Instance()->CdGAFile();
gAlice->Write(0,TObject::kOverwrite);//write AliRun
AliRunLoader::Instance()->Write(0,TObject::kOverwrite);//write RunLoader itself
-
+ //
+ StoreUsedCDBMaps();
+ //
if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();
AliRunLoader::Instance()->Synchronize();
}
else
return 0;
}
+
+//_____________________________________________________________________________
+void AliSimulation::StoreUsedCDBMaps() const
+{
+ // write in galice.root maps with used CDB paths
+ //
+ const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
+ const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
+ //
+ TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
+ cdbMapCopy->SetOwner(1);
+ // cdbMapCopy->SetName("cdbMap");
+ TIter iter(cdbMap->GetTable());
+ //
+ TPair* pair = 0;
+ while((pair = dynamic_cast<TPair*> (iter.Next()))){
+ TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
+ TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
+ if (keyStr && valStr)
+ cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
+ }
+ //
+ TList *cdbListCopy = new TList();
+ cdbListCopy->SetOwner(1);
+ // cdbListCopy->SetName("cdbList");
+ //
+ TIter iter2(cdbList);
+
+ AliCDBId* id=0;
+ while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
+ cdbListCopy->Add(new TObjString(id->ToString().Data()));
+ }
+ //
+ AliRunLoader::Instance()->CdGAFile();
+ gDirectory->WriteObject(cdbMapCopy,"cdbMap","kSingleKey");
+ gDirectory->WriteObject(cdbListCopy,"cdbList","kSingleKey");
+ //
+ AliInfo(Form("Stored used OCDB entries as TMap %s and TList %s in %s",
+ cdbMapCopy->GetName(),
+ cdbListCopy->GetName(),
+ fGAliceFileName.Data()));
+ //
+}
virtual Bool_t IsLegoRun() const {return (fLego!=0);}
AliLego* Lego() const {return fLego;}
virtual void FinishRun();
+ //
+ void StoreUsedCDBMaps() const;
//Quality Assurance
Int_t GetDetIndex(const char * detector);
const AliExternalTrackParam *tpcin = t.GetInnerParam();
const AliExternalTrackParam *tpc=(tpcout)?tpcout:tpcin;
if (!tpc) tpc=¶m;
- Bool_t isOK=recoParam->GetUseOuterDetectors();
+ Bool_t isOK=kTRUE;// RS recoParam->GetUseOuterDetectors();
if (param.GetCovariance()[0]>kmaxC[0]*kmaxC[0]) isOK=kFALSE;
if (param.GetCovariance()[2]>kmaxC[1]*kmaxC[1]) isOK=kFALSE;
if (param.GetCovariance()[5]>kmaxC[2]*kmaxC[2]) isOK=kFALSE;
}
if (((status&AliESDtrack::kITSout)==0)&&(direction==1)) seed->ResetCovariance(10.);
+ //RS if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
//if ( direction ==2 && ((status & AliESDtrack::kTPCout) == 0) ) {
// fSeeds->AddAt(0,i);
void AliTPCtracker::AddCovariance(AliTPCseed * seed){
//
+ return;
// Adding systematic error estimate to the covariance matrix
// !!!! the systematic error for element 4 is in 1/GeV
// 03.03.2012 MI changed in respect to the previous versions
//GetPadLength()*GetPadLength()/12.;
// insert systematic uncertainties
+ /* //RS
if(fkReconstructor){
Double_t sys[15]; memset(sys, 0, 15*sizeof(Double_t));
fkReconstructor->GetRecoParam()->GetSysCovMatrix(sys);
sy2 += sys[0];
sz2 += sys[1];
}
-
+ */
// rotate covariance matrix if no RC
if(!IsRowCross()){
Double_t t2 = GetTilt()*GetTilt();
if(!attach){
AliWarning("No usable AttachClusters calib object.");
} else {
- kScalePulls = attach->GetScaleCov();//*lyScaler;
+ // kScalePulls = attach->GetScaleCov();//*lyScaler;
}
// Retrieve chamber status
SetChmbGood(calibration->IsChamberGood(fDet));
for(int is =0; is<AliPID::kSPECIES; is++) fPID[is] = pid;
const AliExternalTrackParam *par = &t;
+ /* RS
if (t.GetStatus() & AliESDtrack::kTRDbackup) {
par = t.GetOuterParam();
if (!par) {
par = &t;
}
}
+ */
Set(par->GetX()
,par->GetAlpha()
,par->GetParameter()
AliDebug(1, Form("Tracklet Det[%d] !OK", tracklet->GetDetector()));
continue;
}
+ tracklet->FitRobust();
Double_t x = tracklet->GetX();//GetX0();
// reject tracklets which are not considered for inward refit
if(x > t.GetX()+AliTRDReconstructor::GetMaxStep()) continue;
Double_t cov[3]; tracklet->GetCovAt(x, cov);
Double_t p[2] = { tracklet->GetY(), tracklet->GetZ()};
Double_t chi2 = ((AliExternalTrackParam)t).GetPredictedChi2(p, cov);
+ AliInfo(Form("Pl:%d X:%+e : %+e P: %+e %+e Cov:%+e %+e %+e -> dXY: %+e %+e | chi2:%.2f pT:%.2f alp:%.3f",
+ iplane,x,t.GetX(),p[0],p[1],cov[0],cov[1],cov[2],
+ p[0]-t.GetY(),p[1]-t.GetZ(),
+ chi2,t.Pt(),t.GetAlpha()));
if (chi2 < 1e+10 && ((AliExternalTrackParam&)t).Update(p, cov)){
// Register info to track
t.SetNumberOfClusters();
+++ /dev/null
-void aod(){
-
- gSystem->Load("libANALYSIS");
- gSystem->Load("libANALYSISalice");
- gSystem->Load("libCORRFW");
- gSystem->Load("libPWGHFbase");
- gSystem->Load("libPWGmuon");
- gSystem->Load("libESDfilter");
- gSystem->Load("libTENDER");
- gSystem->Load("libPWGPP");
-
- gROOT->Macro("${ALICE_ROOT}/STEER/CreateAODfromESD.C(\"AliESDs.root\",\"AliAOD.root\",\"local://$ALICE_ROOT/OCDB\",\"local://.\")");
-}
+++ /dev/null
-void aod(){
-
- gSystem->Load("libANALYSIS");
- gSystem->Load("libANALYSISalice");
- gSystem->Load("libCORRFW");
- gSystem->Load("libPWGHFbase");
- gSystem->Load("libPWGmuon");
- gSystem->Load("libESDfilter");
- gSystem->Load("libTENDER");
- gSystem->Load("libPWGPP");
-
- gROOT->Macro("${ALICE_ROOT}/STEER/CreateAODfromESD.C(\"AliESDs.root\",\"AliAODs.root\",\"local://$ALICE_ROOT/OCDB\",\"local://..\",kFALSE)");
-}
+++ /dev/null
-void rec() {
-
- AliReconstruction reco;
-
- reco.SetWriteESDfriend();
- reco.SetWriteAlignmentData();
-
- reco.SetInput("raw.root");
-
- reco.SetNumberOfEventsPerFile(-1); // all events in one single file
-
- reco.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- reco.SetSpecificStorage("GRP/GRP/Data",
- Form("local://%s/..",gSystem->pwd()));
- reco.SetRunPlaneEff(kTRUE);
-
- reco.SetRunReconstruction("ALL") ;
- reco.SetRunQA("ALL:ALL") ;
-
- reco.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
-
- for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
- reco.SetQACycles((AliQAv1::DETECTORINDEX_t)det, 999) ;
- reco.SetQAWriteExpert((AliQAv1::DETECTORINDEX_t)det) ;
- }
-
- TStopwatch timer;
- timer.Start();
- reco.Run();
- timer.Stop();
- timer.Print();
-}
simulator.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
+ simulator.SetSpecificStorage("ITS/Align/Data",
+ Form("local://%s",gSystem->pwd()));
+
+
simulator.SetRunQA("ALL:ALL") ;
simulator.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff