Ejemplo n.º 1
0
void Rec(TString file="raw.root")
{
  // Reconstruction of RAW data from the input file raw.root
  // Boris Polichtchouk, 13 Mar 2008

  //AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  //AliCDBManager::Instance()->SetSpecificStorage("PHOS/*","local://BadMap");

  AliReconstruction rec ;
  rec.SetRunTracking("") ;
  rec.SetRunVertexFinder(kFALSE) ; 
  rec.SetRunLocalReconstruction("PHOS") ;
  rec.SetFillESD("PHOS") ;

  //Set rec. parameters different from the default ones.
  AliPHOSRecoParam* recEmc = new AliPHOSRecoParamEmc();
  recEmc->SetSubtractPedestals(kTRUE);
  recEmc->SetMinE(0.01);                     //Minimal Digit energy
  recEmc->SetClusteringThreshold(0.02);      //Minimal cluster seed energy
  recEmc->SetDecoderVersion("v1");           //Comment out to choose Max-Ped version
  recEmc->SetOldRCUFormat(kTRUE);

  AliPHOSReconstructor::SetRecoParamEmc(recEmc);

  rec.SetInput(file.Data());  // read RAW data
  rec.SetNumberOfEventsPerFile(5000);	
  rec.Run();


}
Ejemplo n.º 2
0
void rec() {

  AliReconstruction MuonRec;

  MuonRec.SetInput("raw.root");
  MuonRec.SetRunLocalReconstruction("MUON ITS VZERO");
  MuonRec.SetRunTracking("MUON ITS VZERO");
  MuonRec.SetRunVertexFinder(kTRUE);
  MuonRec.SetFillESD("MUON VZERO HLT");
  MuonRec.SetRunQA("MUON:ALL");
  
  MuonRec.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal/");

  // QA reference
  MuonRec.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;

  // HLT
  MuonRec.SetSpecificStorage("HLT/ConfigMUON/DecisionComponent","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  MuonRec.SetSpecificStorage("HLT/ConfigMUON/HitReconstructor","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  MuonRec.SetSpecificStorage("HLT/ConfigMUON/MansoTrackerFSM","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  MuonRec.SetSpecificStorage("HLT/ConfigMUON/TriggerReconstructor","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  
  // CTP
  MuonRec.SetSpecificStorage("GRP/CTP/Config","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  
  // tracker masks
  MuonRec.SetSpecificStorage("MUON/Calib/Gains","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb/rec");
  MuonRec.SetSpecificStorage("MUON/Calib/Pedestals","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb/rec");

  // reconstruction parameters
  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
  muonRecoParam->SaveFullClusterInESD(kTRUE,100.);
  for (Int_t i = 0; i < 10; i++) {
    muonRecoParam->SetDefaultNonBendingReso(i, 0.1524);
    muonRecoParam->SetDefaultBendingReso(i, 0.05099);
  }
  //muonRecoParam->Print("FULL");
  MuonRec.SetRecoParam("MUON",muonRecoParam);

  MuonRec.SetNumberOfEventsPerFile(500);

  TStopwatch timer;
  timer.Start();
  MuonRec.Run();
  timer.Stop();
  timer.Print();
  
}
Ejemplo n.º 3
0
void runReconstruction(int seed, const char* input, const char* recoptions, bool rawocdb)
{ 
  AliCDBManager* man = AliCDBManager::Instance();
  
  if ( rawocdb ) 
  {
    cout << "**** WILL USE RAW OCDB" << endl;
    man->SetDefaultStorage("raw://"); //alien://folder=/alice/data/2011/OCDB?cacheFold=/Users/laurent/OCDBcache");
    man->SetSpecificStorage("ITS/Calib/RecoParam","alien://folder=/alice/cern.ch/user/p/ppillot/OCDB_PbPbSim");
  } 
  else
  {
    man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");

    man->SetSpecificStorage("GRP/GRP/Data",
                            Form("local://%s",gSystem->pwd()));

  }
  
  gRandom->SetSeed(seed);
  
  AliReconstruction* MuonRec = new AliReconstruction("galice.root");
  MuonRec->SetInput(gSystem->ExpandPathName(input));
  MuonRec->SetRunReconstruction("MUON ITS");
  MuonRec->SetFillESD("HLT");
  MuonRec->SetOption("HLT", "libAliHLTMUON.so");
  MuonRec->SetNumberOfEventsPerFile(10000);
  MuonRec->SetOption("MUON",recoptions);
  MuonRec->SetRunQA("MUON:ALL");
  MuonRec->SetQAWriteExpert(AliQAv1::kMUON);
  MuonRec->SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
  MuonRec->SetWriteESDfriend(kFALSE);
  MuonRec->SetCleanESD(kFALSE);  
  MuonRec->SetStopOnError(kFALSE);
  
  // uncomment the following lines if you want to set custom RecoParam
  // instead of getting them from the OCDB
  //  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
  //  muonRecoParam->SaveFullClusterInESD(kTRUE,100.);
  //  MuonRec->SetRecoParam("MUON",muonRecoParam);
  
  MuonRec->Run();
  
  delete MuonRec;
  
  //gObjectTable->Print();
}
Ejemplo n.º 4
0
void rec() {

  AliReconstruction MuonRec;

  MuonRec.SetInput("raw.root");
  MuonRec.SetRunLocalReconstruction("MUON ITS VZERO");
  MuonRec.SetRunTracking("MUON ITS VZERO");
  MuonRec.SetRunVertexFinder(kTRUE);
  MuonRec.SetFillESD("MUON VZERO HLT");
  MuonRec.SetRunQA("MUON:ALL");
  
  MuonRec.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal/");

  // QA reference
  MuonRec.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;

  // GRP
  MuonRec.SetSpecificStorage("GRP/GRP/Data",Form("local://%s",gSystem->pwd()));
  
  // HLT
  MuonRec.SetSpecificStorage("HLT/ConfigMUON/DecisionComponent","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  MuonRec.SetSpecificStorage("HLT/ConfigMUON/HitReconstructor","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  MuonRec.SetSpecificStorage("HLT/ConfigMUON/MansoTrackerFSM","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  MuonRec.SetSpecificStorage("HLT/ConfigMUON/TriggerReconstructor","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  
  // CTP
  MuonRec.SetSpecificStorage("GRP/CTP/Config","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
  
  // alignment
  MuonRec.SetSpecificStorage("MUON/Align/Data","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb/ideal");
  
  // reconstruction parameters
  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
  muonRecoParam->SaveFullClusterInESD(kTRUE,100.);
  //muonRecoParam->Print("FULL");
  MuonRec.SetRecoParam("MUON",muonRecoParam);

  MuonRec.SetNumberOfEventsPerFile(500);

  TStopwatch timer;
  timer.Start();
  MuonRec.Run();
  timer.Stop();
  timer.Print();
  
}
Ejemplo n.º 5
0
void recTPC(Int_t type, const char *filename="data.root")
{
  /// Set path to calibration data
  ///
  /// type variable = 0 - cosmic test
  ///               = 1 - laser test

  AliCDBManager * man = AliCDBManager::Instance();
  man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  //man->SetRun(0);
  //man->SetSpecificStorage("TPC/*/*","local:///afs/cern.ch/user/m/mivanov/public/Calib");
  //
  // Set reconstruction parameters
  //
  AliLog::SetClassDebugLevel("AliTPCclusterer",2);
  AliTPCRecoParam * tpcRecoParam = 0;
  if (type==0)  tpcRecoParam = AliTPCRecoParam::GetCosmicTestParam(kTRUE);
  if (type>0)  tpcRecoParam = AliTPCRecoParam::GetLaserTestParam(kTRUE);
  tpcRecoParam->Dump();
  AliTPCReconstructor::SetRecoParam(tpcRecoParam);
  AliTPCReconstructor::SetStreamLevel(1);
  //
  //
  //
  AliReconstruction rec;  
  rec.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  rec.SetSpecificStorage("TPC/*/*","local:///afs/cern.ch/user/m/mivanov/public/Calib");
  rec.SetLoadAlignData("");
  rec.SetWriteESDfriend(kTRUE);
  rec.SetInput(filename);
  rec.SetEquipmentIdMap("EquipmentIdMap.data");
  rec.SetRunReconstruction("TPC");
  rec.SetOption("TPC","PedestalSubtraction");
  //  rec.SetRunLocalReconstruction("");
  //  rec.SetRunTracking("TPC");
  rec.SetFillESD("TPC");
  rec.SetFillTriggerESD(kFALSE);
  rec.SetRunVertexFinder(kFALSE);
  rec.SetWriteAlignmentData(kTRUE);
  rec.Run();
}
Ejemplo n.º 6
0
void AliPMDRec()
{
  // This macro for the full reconstruction chain. Only PMD is ON.
  //
  AliCDBManager * man = AliCDBManager::Instance();
  man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  man->SetRun(0);


  Int_t firstEvent = 0;
  Int_t lastEvent = 1;

  AliReconstruction rec;
  rec.SetRunReconstruction("PMD");
  rec.SetRunVertexFinder(kFALSE);
  rec.SetFillESD("PMD");
  rec.SetFillTriggerESD(kFALSE);

  //  rec.Run("./");
  //  rec.Run("raw.date");
  rec.Run("raw_6b_61.root",firstEvent,lastEvent);

}
Ejemplo n.º 7
0
void histogramHandlerTest(const char* input="./"){
  
  if (!input) {
    cerr << "please specify input or run without arguments" << endl;
    return;
  }
  
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  // 
  // init the HLT system in order to define the analysis chain below
  //
  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();

  ///////////////////////////////////////////////////////////////////////////////////////////////////
  //
  // define the analysis chain to be run
  //
    
  int iMinSlice=0; 
  int iMaxSlice=35;
  int iMinPart=0;
  int iMaxPart=5;

  TString histogramHandlerInput1;
  TString histogramHandlerInput2;
  TString histogramHandlerOutput1;
  TString histogramHandlerOutput2;
  TString rootFileWriterInput1;
  TString rootFileWriterInput2;

  for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
    for (int part=iMinPart; part<=iMaxPart; part++) {
      TString clusterFinderOutput1;
      TString clusterFinderOutput2;
      TString clusterHistoInput1;
      TString clusterHistoInput2;
      TString clusterHistoOutput1;
      TString clusterHistoOutput2;
      TString arg, publisher;
      // digit publisher components
      int ddlno=768;
      if (part>1) ddlno+=72+4*slice+(part-2);
      else ddlno+=2*slice+part;
      arg.Form("-minid %d -datatype 'DDL_RAW ' 'TPC '  -dataspec 0x%02x%02x%02x%02x", ddlno, slice, slice, part, part);

      publisher.Form("DP_%02d_%d", slice, part);
      AliHLTConfiguration pubconf(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data());

      // first clusterfinder
      clusterFinderOutput1.Form("CF1_%02d_%d", slice, part);
      AliHLTConfiguration cfconf(clusterFinderOutput1.Data(), "TPCClusterFinderDecoder", publisher.Data(), "-timebins 446");//-timebins set to simulated data
      if (clusterHistoInput1.Length()>0) clusterHistoInput1+=" ";
      clusterHistoInput1+=clusterFinderOutput1;

      // second clusterfinder
      clusterFinderOutput2.Form("CF2_%02d_%d", slice, part);
      AliHLTConfiguration cfconf(clusterFinderOutput2.Data(), "TPCClusterFinderDecoder", publisher.Data(), "-timebins 446");//-timebins set to simulated data
      if (clusterHistoInput2.Length()>0) clusterHistoInput2+=" ";
      clusterHistoInput2+=clusterFinderOutput2;
    

      // first cluster histo component
      clusterHistoOutput1.Form("CH1_%02d_%d", slice, part);
      AliHLTConfiguration cfconf(clusterHistoOutput1.Data(), "TPCClusterHisto", clusterHistoInput1.Data(), "");
      if (histogramHandlerInput1.Length()>0) histogramHandlerInput1+=" ";
      histogramHandlerInput1+=clusterHistoOutput1;

      //second cluster histo component
      clusterHistoOutput2.Form("CH2_%02d_%d", slice, part);
      AliHLTConfiguration cfconf(clusterHistoOutput2.Data(), "TPCClusterHisto", clusterHistoInput2.Data(), "");
      if (histogramHandlerInput1.Length()>0) histogramHandlerInput1+=" ";
      histogramHandlerInput1+=clusterHistoOutput2;
      if (histogramHandlerInput2.Length()>0) histogramHandlerInput2+=" ";
      histogramHandlerInput2+=clusterHistoOutput2;

    }
  }
  
  // first histogram handler component
  histogramHandlerOutput1.Form("HH1_%02d_%d", slice, part);
  AliHLTConfiguration cfconf(histogramHandlerOutput1.Data(), "TPCHistogramHandler", histogramHandlerInput1.Data(), "-use-general");
  if (rootFileWriterInput1.Length()>0) rootFileWriterInput1+=" ";
  rootFileWriterInput1+=histogramHandlerOutput1;
  
  // second histogram handler component
  histogramHandlerOutput2.Form("HH2_%02d_%d", slice, part);
  AliHLTConfiguration cfconf(histogramHandlerOutput2.Data(), "TPCHistogramHandler", histogramHandlerInput2.Data(), "-use-general");
  if (rootFileWriterInput2.Length()>0) rootFileWriterInput2+=" ";
  rootFileWriterInput2+=histogramHandlerOutput2;
  
  AliHLTConfiguration rootFileWriter1("RootFileWriter1", "ROOTFileWriter", rootFileWriterInput1.Data() , "-datafile histogramHandlerFile1");

  AliHLTConfiguration rootFileWriter2("RootFileWriter2", "ROOTFileWriter", rootFileWriterInput2.Data() , "-datafile histogramHandlerFile2");


  ///////////////////////////////////////////////////////////////////////////////////////////////////
  //
  // Init and run the reconstruction
  // All but HLT reconstruction is switched off
  //
  AliReconstruction rec;
  rec.SetInput(input);
  rec.SetRunVertexFinder(kFALSE);
  rec.SetRunLocalReconstruction("HLT");
  rec.SetRunTracking("");
  rec.SetLoadAlignFromCDB(0);
  rec.SetRunQA(":");
  //rec.SetFillESD("HLT");
  rec.SetFillESD("");
  rec.SetFillTriggerESD(false);
  rec.SetOption("HLT", "libAliHLTUtil.so libAliHLTRCU.so libAliHLTTPC.so loglevel=0x7c chains=RootFileWriter1,RootFileWriter2");
  rec.Run();
}
Ejemplo n.º 8
0
/**
 * @file cal-hlt-tpc-offline.C
 * @brief Test macro for the HLT TPC offline calibration.
 *
 * The macro runs an HLT chain of TPC analysis, using the offline
 * algorithms and appropriate wrappers. The final output is
 * processed by the TPCOfflineCalibration component.
 *
 * Usage:
 * <pre>
 *   aliroot -b -q cal-hlt-tpc-offline.C | tee cal-hlt-tpc-offline.log
 * </pre>
 *
 * The chain to be run is defined by the macro given to the parameter
 * 'config='
 *
 * The macro asumes raw data to be available in the rawx folders, either
 * simulated or real data. A different input can be specified as parameter
 * <pre>
 *   aliroot -b -q cal-hlt-tpc-offline.C'("input.root")'
 * </pre>
 *
 * In the first section, an analysis chain is defined. The scale of the
 * chain can be defined by choosing the range of sectors and partitions.
 *
 * The reconstruction is steered by the AliReconstruction object in the
 * usual way.
 *
 * @ingroup alihlt_tpc
 * @author Jacek Otwinowski <*****@*****.**>, [email protected]
 */
void cal_hlt_tpc_offline(const char* input="./")
{
  if (!input) {
    cerr << "please specify input or run without arguments" << endl;
    return;
  }

  ///////////////////////////////////////////////////////////////////////////////////////////////////
  //
  // init the HLT system in order to define the analysis chain below
  //
  AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();

  //gHLT.SwitchAliLog(0);

  ///////////////////////////////////////////////////////////////////////////////////////////////////
  //
  // define the analysis chain to be run
  //

  bool sectorClusterer=true; // run clusterer on sector or DDL level
  // check if the AliRawReaderMemory supports multiple buffers
  TClass* info=TClass::GetClass("AliRawReaderMemory");
  TList* methods=info->GetListOfAllPublicMethods();
  if (sectorClusterer && !methods->FindObject("AddBuffer")) {
    cerr << "warning: AliRawReaderMemory does not support multiple buffers, falling back to run clusterer on DDL level" << endl;
    sectorClusterer=false;
  }
 
  int iMinSlice=0;
  int iMaxSlice=35;
  int iMinPart=0;
  int iMaxPart=5;

  int DDLNoFromSlicePatch(int, int);

  TString writerInput;
  TString trackerInput;
  TString calibratorInput;

  for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
    TString arg, clustererInput;
    for (int part=iMinPart; part<=iMaxPart; part++) {
      TString publisher, cf;

      // raw data publisher components
      int ddlno=DDLNoFromSlicePatch(slice, part);
      arg.Form("-minid %d -datatype 'DDL_RAW ' 'TPC '  -dataspec 0x%02x%02x%02x%02x -verbose", ddlno, slice, slice, part, part);
      publisher.Form("DP_%02d_%d", slice, part);
      AliHLTConfiguration pubconf(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data());

      if (!sectorClusterer) {
      // cluster finder components
      cf.Form("CF_%02d_%d", slice, part);
      AliHLTConfiguration cfconf(cf.Data(), "TPCOfflineClusterer", publisher.Data(), "");

      if (trackerInput.Length()>0) trackerInput+=" ";
      trackerInput+=cf;
      //if (writerInput.Length()>0) writerInput+=" ";
      //writerInput+=cf;
      } else {
	if (clustererInput.Length()>0) clustererInput+=" ";
	clustererInput+=publisher;
      }
    }
    if (sectorClusterer) {
      // cluster finder components
      cf.Form("CF_%02d", slice);
      AliHLTConfiguration cfconf(cf.Data(), "TPCOfflineClusterer", clustererInput.Data(), "");

      if (trackerInput.Length()>0) trackerInput+=" ";
      trackerInput+=cf;
    }
  }

  // one global tracker component
  TString tracker;
  tracker.Form("Global_TR");
  AliHLTConfiguration trackerconf(tracker.Data(), "TPCOfflineTrackerCalib", trackerInput.Data(), "");
  if (writerInput.Length()>0) writerInput+=" ";
  calibratorInput+=tracker;

  // one global calibration component
  TString calibrator;
  calibrator.Form("Global_Calib");
  AliHLTConfiguration calibconf(calibrator.Data(), "TPCOfflineCalibration", calibratorInput.Data(), "");
  if (writerInput.Length()>0) writerInput+=" ";
  writerInput+=calibrator;

  // the writer configuration
  AliHLTConfiguration rootfwconf("sink1", "ROOTFileWriter", writerInput.Data(), "-specfmt=_%d -subdir=out_%d -idfmt=_0x%08x");
  //AliHLTConfiguration esdwconf("sink1", "EsdCollector"   , writerInput.Data(), "-directory hlt-tpc-offline");

  ///////////////////////////////////////////////////////////////////////////////////////////////////
  //
  // Init and run the reconstruction
  // All but HLT reconstructio is switched off
  //
  AliReconstruction rec;
  rec.SetInput(input);
  rec.SetRunVertexFinder(kFALSE);
  rec.SetRunLocalReconstruction("HLT");
  rec.SetRunTracking("");
  rec.SetLoadAlignFromCDB(0);
  rec.SetFillESD("");
  rec.SetRunQA(":");
  rec.SetRunGlobalQA(kFALSE);
  rec.SetFillTriggerESD(kFALSE);
  rec.SetOption("HLT", "libAliHLTUtil.so libAliHLTRCU.so libANALYSIS.so libANALYSISalice.so libTPCcalib.so libAliHLTTPC.so loglevel=0x7c chains=sink1");
  rec.Run();
}
Ejemplo n.º 9
0
void AliTRDReconstructandFill() 
{
  //
  // This macro fills 2d histo or vectors during the reconstruction
  // If it is vectors, it fits them directly after the reconstruction
  // and writes the result in the file coeftest.root
  //
 
  TStopwatch timer;
  timer.Start();

  ////Set the parameters of AliTRDCalibra***************
  AliTRDCalibra *calibra = AliTRDCalibra::Instance();

  ////What do you want to use?
  calibra->SetMITracking(); //Offline tracking
  //calibra->Setmcmtracking();
  
  
  ////Do you want to try the correction due to the angles of the tracks for mcm tracklets?
  calibra->SetMcmCorrectAngle();
  
  ////What do you want to fill?
  calibra->SetCH2dOn();//relative gain calibration
  calibra->SetPH2dOn();//drift velocity and time0 calibration
  calibra->SetPRF2dOn();//Pad Response Function calibration


  ////How do you want to store the infos?
  calibra->SetVector2d();//vector method
  calibra->SetHisto2d();//2Dhistograms

  ////Which mode do you want?
  calibra->SetNz(2,2);//For the PRF z direction
  calibra->SetNrphi(2,2);//For The PRF rphi direction
  calibra->SetNz(0,0);//For the gain z direction
  calibra->SetNrphi(0,0);//For the gain rphi direction
  calibra->SetNz(1,3);//For the drift velocity and time0 z direction
  calibra->SetNrphi(1,3);//For the drift velocity and time 0 rphi direction

  ////How many bins?
  calibra->SetNumberBinCharge(100);
  calibra->SetNumberBinPRF(20);
  
  
  ////Do you want to accept more tracks?
  calibra->SetProcent(1.2);//For the gain if one group has a signal above 1.2 the other group then fill
  calibra->SetDifference(10);//For the drift velocity if one group has at least 10 time bins then fill
  calibra->SetNumberClusters(18);//For mcm tracklets only fill only with tracklet with at least 18 clusters
  
  ////Do you want to take only the middle pad for gain or Vdrift?
  //calibra->SetTraMaxPad();
  
  //Do you want to apply more strict cut on the clusters for the PRF calibration?
  calibra->SetThresholdClusterPRF1(2);//The neighbors pads must have a signal smaller than 2 ADC counts
  calibra->SetThresholdClusterPRF2(10);//The 3 pads in the cluster must have a signal above 10 ADC counts
  
  
  ////What do you want to write?
  calibra->SetWrite(0);//For the gain
  calibra->SetWrite(1);//For the average pulse height
  calibra->SetWrite(2);//For the PRF
  
  
  ////If you want to change the name of the file where it is stored (not very good)
  //calibra->SetWriteName("test.root");
  
  
  //Begin the reconstruction
  AliReconstruction rec;
  rec.SetGAliceFile("galice.root"); 
  rec.SetLoadAlignFromCDB(kFALSE);
  rec.SetRunHLTTracking(kFALSE);
  rec.SetFillESD("");
  rec.SetFillTriggerESD(kFALSE);
  rec.SetRunVertexFinder(kFALSE);
  rec.Run();
  timer.Stop();
  timer.Print();
  calibra->Write2d();    


  TStopwatch timerfit;
  timerfit.Start();
  ////Fit directly after having filling****

  ////Do you want to try with less statistics?
  calibra->SetMinEntries(10);//If there is at least 10 entries in the histo, it will fit

  ////Do you want to write the result?
  calibra->SetWriteCoef(0);//gain
  calibra->SetWriteCoef(1);//time 0 and drift velocity
  calibra->SetWriteCoef(2);//PRF

  ////Do you want to change the name of the file (TRD.coefficient.root)?
  calibra->SetWriteNameCoef("coeftest.root");

  ////Do you want to see something?
  calibra->SetDebug(1);

  ////Do you want to fit?
  calibra->FitPHOnline(); 
  calibra->FitCHOnline(); 
  calibra->FitPRFOnline();  
  
  
  timerfit.Stop();
  timerfit.Print();

}
Ejemplo n.º 10
0
void main_recCPass1_OuterDet(const char *filename="raw.root",Int_t nevents=-1, const char *ocdb="raw://", Bool_t useFullITS=kFALSE)
{
  // Load some system libs for Grid and monitoring
  // Set the CDB storage location
  AliCDBManager * man = AliCDBManager::Instance();
  man->SetDefaultStorage(ocdb);
  // Reconstruction settings
  AliReconstruction rec;
  // Upload CDB entries from the snapshot (local root file) if snapshot exist
  if (gSystem->AccessPathName("OCDB.root", kFileExists)==0) {        
    man->SetDefaultStorage("local://");
    man->SetRaw(kFALSE);
    man->SetSnapshotMode("OCDB.root");
  }
  if (gSystem->AccessPathName("localOCDBaccessConfig.C", kFileExists)==0) {        
    gInterpreter->ProcessLine("localOCDBaccessConfig();");
  }

  if(!useFullITS){
    // only SPD-trackletting will be done
    printf("Special ITS configuration: only SPD-trackletting will be done\n");
    rec.SetRecoParam("ITS",GetSpecialITSRecoParam());
  }

  // All friends
  rec.SetFractionFriends(1.0);

 // AliReconstruction settings - hardwired MB trigger for calibration

  TString newfilename = filename;
  newfilename += "?Trigger=kCalibOuter";
  rec.SetInput(newfilename.Data());

  // Set protection against too many events in a chunk (should not happen)
  if (nevents>0) rec.SetEventRange(0,nevents);

  // Remove recpoints after each event
  rec.SetDeleteRecPoints("ITS MUON EMCAL PHOS VZERO T0");

  // Switch off the V0 finder - saves time!
  rec.SetRunV0Finder(kFALSE); 

  //
  // QA options - all QA is off
  //
  rec.SetRunQA(":");
  rec.SetRunGlobalQA(kFALSE);

  // AliReconstruction settings
  rec.SetWriteESDfriend(kFALSE);
  if(!useFullITS) rec.SetWriteAlignmentData(kFALSE);
  else rec.SetWriteAlignmentData();
  rec.SetUseTrackingErrorsForAlignment("ITS");
  rec.SetRunReconstruction("ITS MUON EMCAL PHOS VZERO T0");
  rec.SetFillESD("ITS MUON EMCAL PHOS VZERO T0");
  rec.SetCleanESD(kFALSE);

  // Specific reco params for ZDC (why isn't this automatic?)
//  rec.SetRecoParam("ZDC",AliZDCRecoParamPbPb::GetHighFluxParam(2760));

  //Ignore SetStopOnError
  rec.SetStopOnError(kFALSE);

  AliLog::Flush();
  rec.Run();
}