/// \file AliBarrelRec_TPCparam.C
/// \brief Macro to create AliESDs.root using parametrized TPC tracking and AliITStrackerSA (MI + SA)
-///
+///
/// Input files:
/// - galice.root
/// - Kinematics.root
/// - TrackReferences.root
/// - ITS.RecPoints.root (use AliRecontruction class)
/// - ITS.Vertex.root (use $ALICE_ROOT/ITS/AliITSVertexerZTest.C)
-///
+///
/// \author A. Dainese - INFN Legnaro
void AliBarrelRec_TPCparam(Int_t firstEvent=0,Int_t lastEvent=0) {
/// \file AliL1Delay.C
/// \brief Macro that measures the time delay of L1 trigger in TPC
-///
+///
/// It reads the ESD tracks and fills histograms with the distance
/// between the primary vertex and the Z position
/// of the point of closest approach between the track and the beam axis.
/// alone.
/// The propagation to the vertex can be done either with or without
/// TGeoManager.
-///
+///
/// \author Cvetan Cheshkov <Cvetan.Cheshkov@cern.ch>
#if !defined(__CINT__) || defined(__MAKECINT__)
}
Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
- //--------------------------------------------------------------------
- // Correction for the material between the TPC and the ITS
- // (should it belong to the TPC code ?)
- //--------------------------------------------------------------------
+ /// Correction for the material between the TPC and the ITS
+ /// (should it belong to the TPC code ?)
+
Double_t riw=80., diw=0.0053, x0iw=30; // TPC inner wall ?
Double_t rcd=61., dcd=0.0053, x0cd=30; // TPC "central drum" ?
Double_t yr=12.8, dr=0.03; // rods ?
Bool_t PropagateToVertex(AliESDtrack *track, Float_t *vtxXYZ)
{
- // Make an ITS track and propagate it to the vertex
+ /// Make an ITS track and propagate it to the vertex
+
AliITStrackV2 itstrack(*track);
if (CorrectForDeadZoneMaterial(&itstrack) != 0) return 0;
if (!itstrack.PropagateTo(3.,0.0028,65.19)) return 0;
Bool_t PropagateToVertexG(AliESDtrack *track, Float_t *vtxXYZ)
{
- // Make an ITS track and propagate it to the vertex using TGeoManager
+ /// Make an ITS track and propagate it to the vertex using TGeoManager
+
AliITStrackV2 itstrack(*track);
AliExternalTrackParam etrack(itstrack);
Double_t r = 3.;
/// \file AliTPCCmpNG.C
-///
+///
/// version: 1.0
/// description:
/// define a class TPCGenTrack
/// save TPC related properties of tracks into a single tree
-///
+///
/// input:
/// Int_t nEvents ... nr of events to process
/// Int_t firstEventNr ... first event number (starts from 0)
/// char* fnHits ... name of file with hits and Kine Tree
/// char* fnDigits ... name of file with digits
/// char* fnTracks .. output file name, default genTracks.root
-///
+///
/// How to use:
/// Typical usage:
/// .L AliTPCCmpNG.C+
/// .L AliTPCCmpNG.C+
/// TPCCmpTr *t2 = new TPCCmpTr("tpc.tracks.root","genTracks.root","cmpTracks.root");
/// t2->Exec();
-///
+///
/// Details:
-///
+///
/// Step 1 - summurize information from simulation
-///
+///
/// Compile macro with ACLIC:
/// .L AliTPCCmpNG.C+
/// create an object TPCFindGenTracks, which processes information
/// t->Exec(nEvents, firstEvent)
/// Then you have to quit root to get rid of problems with deleting gAlice
/// object (it is not deleted, but read again in the following step):
-///
+///
/// Step 2 - compare reconstructed tracks with simulated
-///
+///
/// Load (and compile) the macro:
/// .L AliTPCCmpNG.C+
/// Create object TPCCmpTr, which does the comparison. As input it requires
/// The interface is quite similar to the TPCFindGenTracks class.
/// Then just invoke Exec() method:
/// t2->Exec();
-///
+///
/// Step 3 - study the results
-///
+///
/// Load the outoput TTree and you can do Draw(), Scan() or other
/// usual things to do with TTree:
/// TFile *f = new TFile("cmpTracks.root")
/// TTree *t = (TTree*)f->Get("TPCcmpTracks")
/// t->Draw("fVDist[3]","fReconstructed")
-///
+///
/// History:
-///
+///
/// 24.09.02 - first version
/// 24.01.03 - v7, before change from TPC Special Hits to TrackReferences
/// 26.01.03 - change from TPC Special Hits to TrackReferences
/// into separate step
/// 03.02.03 - rename to AliTPCCmpNG.C, remove the part with rec. tracks
/// (will be addded in a macro AliTPCCmpTr.C
-///
+///
/// \author Jiri Chudoba
/// \date 24.09.2002
////////////////////////////////////////////////////////////////////////
void WaitForReturn()
{
-//
-// wait until user press return;
-//
+/// wait until user press return;
+
char *input;
Bool_t done = kFALSE;
TTimer *timer = new TTimer("gSystem->ProcessEvents();", 50, kFALSE);
////////////////////////////////////////////////////////////////////////
Int_t Chain(TString baseDir, TString subDirNameMask, TString fn, TChain& chain) {
-// chain all files fn in the subdirectories which match subDirName
-// return number of chained files
+/// chain all files fn in the subdirectories which match subDirName
+/// return number of chained files
// open baseDir, loop over subdirs
}
////////////////////////////////////////////////////////////////////////
Bool_t ImportgAlice(TFile *file) {
-// read in gAlice object from the file
+/// read in gAlice object from the file
+
gAlice = (AliRun*)file->Get("gAlice");
if (!gAlice) return kFALSE;
return kTRUE;
ClassDef(TPCCmpTr,1) // class which creates and fills tree with TPCGenTrack objects
};
+/// \cond CLASSIMP
ClassImp(TPCCmpTr)
+/// \endcond
////////////////////////////////////////////////////////////////////////
TPCCmpTr::TPCCmpTr()
**************************************************************************/
/// \class AliTPCCombinedTrackfit
-///
+///
/// Combine cosmic track pairs (upper, lower) and do track fitting
-///
+///
/// \author Xianguo Lu <lu@physi.uni-heidelberg.de>
#include <TAxis.h>
/// \class AliTPCCombinedTrackfit
/// \brief Combine cosmic track pairs (upper, lower) and do track fitting.
-///
+///
/// Usage
/// -----
///
/// const Bool_t kfit = fCombinedTrackfit->CombineESDtracks(esdtrack0, esdtrack1);
///
/// //status = 0 for good fit (i.e. kfit=kTRUE), non-0 for bad fit (i.e. kfit=kFALSE), see "enum CombineStatus" definition in header file
-/// const Int_t status = fCombinedTrackfit->GetStatus();
+/// const Int_t status = fCombinedTrackfit->GetStatus();
///
-/// //in Analysis Task write when terminate
+/// //in Analysis Task write when terminate
/// fCombinedTrackfit->GetStreamer()->GetFile()->Write();
/// ~~~
///
/// "icup.="<<&fInnerClusterUp<< //TVector3 position of the innermost cluster of the upper track
/// "iclow.="<<&fInnerClusterLow<<
/// "leverarm="<<fLeverArm<<
-/// "ncl="<<fFitNcls<< //number of clusters used in successful propagation
+/// "ncl="<<fFitNcls<< //number of clusters used in successful propagation
/// "nmiss="<<fMissNcls<< //number of clusters failed in propagation, should always be 0 in this case.
-/// "chi2="<<fPreChi2<< //chi2/nfit
+/// "chi2="<<fPreChi2<< //chi2/nfit
/// "momup="<< momup << //momentum at uppermost cluster with upward propagation
/// "momlow="<< momlow << //momentum at lowermost cluster with downward propagation
/// "ptup="<< ptup <<
/// ----------
///
/// For 2011 Feb. cosmic data nch=2 events, the kfit and status look like:
-///
+///
/// ~~~{.cxx}
/// kfit,status ( 0, 1): 68939 / 2611959 = 2.639% //kFailGetTPCseeds
/// kfit,status ( 0, 2): 14886 / 2611959 = 0.570% //not both tracks have ncl > AliTPCCosmicUtils::fgkNclsMin
/// kfit,status ( 0, 7): 19994 / 2611959 = 0.765% //chi2/nfit > fgkMaxChi2
/// kfit,status ( 1, 0): 2402181 / 2611959 = 91.969% //i.e. 92% of nch=2 events are successfully fitted.
/// ~~~
-///
+///
/// Resolution
/// ----------
///
+/// \file AliTPCCompareTracks.C
+
#ifndef __CINT__
#include "alles.h"
#include "AliComplexCluster.h"
//#include "AliTPCclusterM.h"
+
#include "AliTPCclusterMI.h"
#endif
-/// \file AliTPCCompareTracks.C
-
Int_t AliTPCCompareTracks(Int_t eventn, Bool_t all = kFALSE) {
cerr<<"Comparing tracks...\n";
//CONNECT FILES
/***********************************************************************/
TFile *inkin = TFile::Open("rfio:galice.root");
-/// \file AliTPCComparison2.C
-/// if(gAlice)delete gAlice; COMMENTED BECAUSE OF A BUG (IN COMPILED MODE)
+// \file AliTPCComparison2.C
+// if(gAlice)delete gAlice; COMMENTED BECAUSE OF A BUG (IN COMPILED MODE)
gAlice = (AliRun*)inkin->Get("gAlice");
cout<<"AliRun object found on file "<<gAlice<<endl;
digp= (AliTPCParam*)cf->Get("75x40_100x60_150x60");
if (!digp) { cerr<<"TPC parameters have not been found !\n"; return 2; }
}
- ///////////
+
TObjArray tarray(MAX);
AliTPCtrack *iotrack=0;
Int_t nentr= 0;
Int_t good_tracks(GoodTrackTPC *gt, Int_t max, Int_t firstev, Int_t eventn) {
- //eventn - number of events in file
+ /// eventn - number of events in file
TFile *file=TFile::Open("galice.root");
if (!file->IsOpen()) {cerr<<"Can't open galice.root !\n"; exit(4);}
+/// \file AliTPCDDL.C
+
#if !defined(__CINT__)
#include <TFile.h>
#include <TTree.h>
void AliTPCDDL(Int_t eventNumber=0, Int_t eth=0){
-/// \file AliTPCDDL.C
-/// eth is a threshold.
-/// Digits stored into a file have an amplitude value greater than "eth"
+ /// eth is a threshold.
+ /// Digits stored into a file have an amplitude value greater than "eth"
const char * inFile_new = "galice.root";
AliRunLoader *rl = AliRunLoader::Open(inFile_new,"Event","read");
/// \file AliTPCDisplayDigits.C
+///
/// \author I.Belikov, CERN, Jouri.Belikov@cern.ch
#ifndef __CINT__
fIs2D(kTRUE),
fWorkspace(0) // file with trees, pictures ...
{
- ///
+ ///
for (Int_t i=0; i<3; i++){
fMin[i]=0; fMax[i]=0;
fUseLinear(useLinear),
fWorkspace(0) // file with trees, pictures ...
{
- ///
+ ///
for (Int_t i=0; i<3; i++){
fMin[i]=0; fMax[i]=0;
}
TTree * AliTPCEfield::GetTree(const char * tname){
- ///
+ ///
return ((*fWorkspace)<<tname).GetTree();
}
TMatrixD* AliTPCEfield::MakeCorrelation(TMatrixD &matrix){
- ///
+ ///
Int_t nrows = matrix.GetNrows();
TMatrixD * mat = new TMatrixD(nrows,nrows);
void AliTPCEfield::DumpField(Double_t gridSize, Double_t step){
- ///
+ ///
Double_t stepSize=0.001*fScale/fMaxFreq;
//
void MakeTPC2DExample(AliTPCEfield *field){
- //
+ ///
+
/*
.L $ALICE_ROOT/TPC/AliTPCEfield.cxx++
AliTPCEfield *field = new AliTPCEfield("field",20, kTRUE,kTRUE);
**************************************************************************/
/// \class AliTPCExBConical
-///
+///
/// Calculates the space point distortions due to the conical shape of ALICE TPC.
-///
+///
/// Becasue of mechanical deformation ALICE TPC, chambers are misaligned in z direction
/// TPC has roughly conical shape
-///
+///
/// For the moment ONLY efective correction used - NOT EDGE EFFECT calcualted
-///
+///
/// The class allows "effective Omega Tau" corrections.
-///
+///
/// Example usage:
///
/// ~~~{.cxx}
/// // plot dRPhi distortions ...
/// conical.CreateHistoDRPhiinZR(1.,100,100)->Draw("surf2");
/// ~~~
-///
+///
/// \author Marian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
/// \date 02/05/2010
#include "TMath.h"
#include "AliTPCROC.h"
#include "AliTPCExBConical.h"
+/// \cond CLASSIMP
ClassImp(AliTPCExBConical)
+/// \endcond
AliTPCExBConical::AliTPCExBConical()
: AliTPCCorrection("exb_conical","ExB conical"),
-/****************************************************************************
- * Origin: M.Ivanov marian.ivanov@cern.ch *
- ****************************************************************************/
-
-/*
-
- macro to create array of clusters from TPC digits
- input files - galice.root
- digits.root - file with digits - usualy use link to galice.root
- - in splitted mode - neccesary to create link to proper file
-
- output file - AliTPCclusters.root
- - to be used by AliTPCTrackFinderMI.C
-
- Warning - if cluster file AliTPCclusters.root already exist - macro exit and don't produce anything
-
-
-*/
-
+/// \file AliTPCFindClusters.C
+///
+/// \author M.Ivanov marian.ivanov@cern.ch
+///
+/// macro to create array of clusters from TPC digits
+/// input files - galice.root
+/// digits.root - file with digits - usualy use link to galice.root
+/// - in splitted mode - neccesary to create link to proper file
+///
+/// output file - AliTPCclusters.root
+/// - to be used by AliTPCTrackFinderMI.C
+///
+/// Warning - if cluster file AliTPCclusters.root already exist - macro exit and don't produce anything
#ifndef __CINT__
#include <iostream.h>
+/// \file AliTPCH5OptimizedTables.C
+///
+/// This macro compress and decompress an Altro format file using Huffman technique with 5 tables
+
#if !defined(__CINT__)
#include <Riostream.h>
#include <TStopwatch.h>
#include "AliTPCCompression.h"
#endif
-/*
-This macro compress and decompress an Altro format file using Huffman technique with 5 tables
-*/
-
void AliTPCH5OptimizedTables(const char* fSource="AltroFormat.dat",const char* fDest="CompressedData.dat"){
cout<<"Source file: "<<fSource<<" Output file: "<<fDest<<endl;
static const Int_t NumTable=5;
+/// \file AliTPCHits2Digits.C
+
#if !defined(__CINT__) || defined(__MAKECINT__)
#include <Riostream.h>
extern AliRun *gAlice;
Int_t AliTPCHits2Digits(Int_t nev=5) {
- // Connect the Root Galice file containing Geometry, Kine and Hits
+ /// Connect the Root Galice file containing Geometry, Kine and Hits
+
if (gAlice) {
delete AliRunLoader::Instance();
delete gAlice;//if everything was OK here it is already NULL
+/// \file AliTPCMonitorExec.C
+
void AliTPCMonitorExec(Int_t val)
{
AliTPCMonitor* moni =0;
/// \file AliTPCSavePID.C
-///
-/// \author Dubna, 22 Jan 2003
+///
+/// \author Dubna
+/// \date 2003, 22 Jan
Int_t AliTPCSavePID(Int_t emax=3) {
-///////////////////////////////////////
+///
+
#include<fstream.h>
TFile *inkin = TFile::Open("galice.root");
if (!inkin->IsOpen()) {
/// \file AliTPCScanPID.C
/// \brief Test macro for AliTPCtracksPid.root file
///
-/// \author JINR Dubna Aug 2002
+/// \author JINR Dubna
+/// \date Aug 2002
void
AliTPCScanPID(Int_t evNumber2=3) {
//................. Prepare histogramms ................
+
TH2F *qplot = new TH2F("Qtrm","Qtrm vs Pmom",100,0,1300,100,0,13);
TH2F *qplotP= new TH2F("Qtrm1","Qtrm vs Pmom",100,0,1300,100,0,13);
TH2F *qplotKa= new TH2F("Qtrm2","Qtrm vs Pmom",100,0,1300,100,0,13);
/// - only the amplitude should be different - by factor of sqrt
///
/// \author Marian Ivanov
-
+
void testmerge()
{
/// merge two example events
- ///
+ ///
/// it merge two events -one from current directory -second from directory ev2
if(gAlice) delete gAlice;
+/// \file AliTPCtrackingParamDB.C
+
/****************************************************************************
* This macro is used to create a DataBase for the TPC tracking *
* parameterization. *
//_____________________________________________________________________________
Int_t TPCParamTracks(const Int_t coll,Int_t firstEvent,Int_t lastEvent) {
-//
-// Ordinary TPC tracking parameterization
-//
+/// Ordinary TPC tracking parameterization
/**** Initialization of the NewIO *******/
}
//_____________________________________________________________________________
void CreateAllGeantTracks(const Int_t coll,Int_t nev) {
-//
-// Get all tracks at TPC 1st hit w/o selection and smearing
-//
+/// Get all tracks at TPC 1st hit w/o selection and smearing
+
cerr<<"\n*******************************************************************\n";
const Char_t *name="CreateAllGeantTracks";
}
//_____________________________________________________________________________
void TrackCompare(const Int_t coll,const Double_t Bfield,Int_t n) {
-//
-// Compare Kalman tracks with tracks at TPC 1st hit
-//
+/// Compare Kalman tracks with tracks at TPC 1st hit
+
cerr<<"\n*******************************************************************\n";
const Char_t *name="TrackCompare";
}
//_____________________________________________________________________________
void BuildDataBase(const Int_t coll,const Double_t Bfield) {
-//
-//
-//
+///
+
cerr<<"\n*******************************************************************\n";
AliTPCtrackerParam tracker(coll,Bfield);
/// \file AnalyzeESDtracks.C
-///
+///
/// \brief Process ESD tracks - extract TPC tracks - write them to tree
/*
void LaserCalib(TTreeSRedirector & cstream, TTree * chain, Float_t tmin, Float_t tmax, Float_t fraction=0.7);
void AnalyzeESDtracks(Int_t run){
- //
- // output redirect
+ // output redirect
TTreeSRedirector * pcstream = new TTreeSRedirector("TPCtracks.root");
TTreeSRedirector &cstream = *pcstream;
//
void LaserCalib(TTreeSRedirector & cstream, TTree * chain, Float_t tmin, Float_t tmax, Float_t fraction){
- //
- //
- //
+ ///
+
const Double_t kMaxDelta=10;
AliTPCParamSR param;
param.Update();
/// \file ClassTree.C
/// \brief Macro generated from canvas: ClassTree
///
-/// \author ROOT version 2.21/07
/// \date Tue Jun 1 17:01:38 1999
+///
+/// ROOT version 2.21/07
void ClassTree()
{
///
/// Input files:
///
-/// * galice.root
+/// * galice.root
/// * digits.root: file with digits - usualy use link to galice.root
/// in splitted mode - neccesary to create link to proper file
///
Int_t FindKrClusters(){
- //
- //Load DataBase
- //
+ // Load DataBase
//char *ocdbpath ="local:///afs/cern.ch/alice/tpctest/OCDB";
//char *ocdbpath ="local:///home/matyja/baza/OCDB";
char *ocdbpath ="local:///data/baza/OCDB";
- //
- // remove Altro warnings
- //
+ /// remove Altro warnings
+
AliLog::SetClassDebugLevel("AliRawReaderDate",-5);
AliLog::SetClassDebugLevel("AliTPCAltroMapping",-5);
AliLog::SetModuleDebugLevel("RAW",-5);
Int_t FindKrClusterCheck(const char *fileName){
- //
- //
+ ///
+
gSystem->Load("$ROOTSYS/lib/libGui");
gSystem->Load("$ROOTSYS/lib/libTree");
gSystem->Load("$MEMSTAT/libMemStat");
#include "TPad.h"
#include "TCanvas.h"
+/// \file LandauTest.C
class TLandauMean: public TObject {
public:
void Init(Int_t n, Float_t mean, Float_t sigma); // initial parameters
void Gener(); // gener sample
- // void Anal();
+ //void Anal();
Int_t fNSample; // number of samples
Float_t fLMean; // landau mean
ClassDef(TLandauMean,1)
};
+/// \cond CLASSIMP
ClassImp(TLandauMean)
+/// \endcond
void TLandauMean::Init(Int_t n, Float_t mean, Float_t sigma)
{
TH1F * LandauTest(Float_t meano, Float_t sigma, Float_t meanlog0, Int_t n,Float_t ratio)
{
- //
- // test for different approach of de dx resolution
- // meano, sigma - mean value of Landau distribution and sigma
- // meanlog0 - scaling factor for logarithmic mean value
- // n - number of used layers
- // ratio - ratio of used amplitudes for truncated mean
- //
-
+ /// test for different approach of de dx resolution
+ /// meano, sigma - mean value of Landau distribution and sigma
+ /// meanlog0 - scaling factor for logarithmic mean value
+ /// n - number of used layers
+ /// ratio - ratio of used amplitudes for truncated mean
+
TCanvas * pad = new TCanvas("Landau test");
pad->Divide(2,2);
+/// \file TestAliTPCDigitsArray.C
+
TFile f("pokus.root","recreate")
arr.MakeTree()
TBrowser b;
void MakePictures(char *dirname){
- //
- //
- //
- // Define Uli Style
+ /// Define Uli Style
+
gROOT->SetStyle("Plain");
gStyle->SetFillColor(10);
gStyle->SetPadColor(10);
void AddChains(Int_t run){
- //
- // add files to the chains + check consistency
- //
+ /// add files to the chains + check consistency
+
ifstream in0;
ifstream in1;
ifstream in2;
}
void Select(){
- //
- // base cut on the tracks
- //
+ /// base cut on the tracks
+
comp.fTree->Draw(">>listTracks","Etrack.fTPCncls>30&&abs(Etrack.fIp.fP[4])<1");
comp.fTree->SetEventList(listTracks);
//
}
void SelectLaser(){
- //
- // base cut on the tracks
- //
+ /// base cut on the tracks
+
comp.fTree->Draw(">>listTracks","Etrack.fTPCncls>20&&abs(Etrack.fIp.fP[4])<1&&abs(Etrack.fIp.fP[3])<0.01");
comp.fTree->SetEventList(listTracks);
//
void PRFYZ(TCut cut0, TCut cut1, char * description){
- //
- // plot Pad response function as funtion of drift z
- //
- //
+ /// plot Pad response function as funtion of drift z
+
TF1 * f1 = new TF1("fdiff","sqrt([0]*[0]+(250-x)*[1]*[1])");
f1->SetParameter(1,0.2);
f1->SetParameter(0,0.2);
void ResYZ(TCut cut0, TCut cut1, char * description){
- //
- // resolution in y coordinate as function of z
- //
+ /// resolution in y coordinate as function of z
+
TF1 * f1 = new TF1("fdiff","sqrt([0]*[0]+(250-x)*[1]*[1])");
f1->SetParameter(1,0.2);
f1->SetParameter(0,0.2);
}
void SysYX(TCut cut0, char * description){
- //
- //
- //
+ ///
+
TProfile * profA = new TProfile("profY","profY",70,89,250);
comp.fTree->Draw("Cl.fY-Track.fTrackPoints.GetY():Track.fTrackPoints.GetX()>>profY","abs(Cl.fY-Track.fTrackPoints.GetY())<1&&Track.fTrackPoints.fTX>10"+cut0,"prof");
profA->SetXTitle("Local X (cm)");
}
void SysZX(TCut cut0, char * description){
- //
- //
- //
+ ///
+
TProfile * profA = new TProfile("profZ","profZ",70,89,250);
comp.fTree->Draw("abs(Cl.fZ)-abs(Track.fTrackPoints.GetZ()):Track.fTrackPoints.GetX()>>profZ","abs(abs(Cl.fZ)-abs(Track.fTrackPoints.GetZ()))<1&&Track.fTrackPoints.fTX>10"+cut0,"prof");
profA->SetXTitle("Local X (cm)");
}
TProfile * ProfileMaxRow(TCut cut0, char *name, Int_t max){
- //
- // make profile histrogram of amplitudes
- //
+ /// make profile histrogram of amplitudes
+
TProfile *profA = new TProfile(name,name,max,0,max-1);
char expr[100];
sprintf(expr,"Cl.fMax:Cl.fRow>>%s",name);
}
TProfile * ProfileMaxPhi(TCut cut0, char *name, Int_t max){
- //
- // make profile histrogram of amplitudes
- //
+ /// make profile histrogram of amplitudes
+
TProfile *profA = new TProfile(name,name,max,-0.14,0.14);
char expr[100];
sprintf(expr,"Cl.fMax:Cl.fY/Cl.fX>>%s",name);
}
TProfile * ProfileQRow(TCut cut0, char *name, Int_t max){
- //
- // make profile histrogram of amplitudes
- //
+ /// make profile histrogram of amplitudes
+
TProfile *profA = new TProfile(name,name,max,0,max-1);
char expr[100];
sprintf(expr,"Cl.fQ:Cl.fRow>>%s",name);
}
TProfile * ProfileQPhi(TCut cut0, char *name, Int_t max){
- //
- // make profile histrogram of amplitudes
- //
+ /// make profile histrogram of amplitudes
+
TProfile *profA = new TProfile(name,name,max,-0.14,0.14);
char expr[100];
sprintf(expr,"Cl.fQ:Cl.fY/Cl.fX>>%s",name);
}
TProfile * ProfileQZ(TCut cut0, char *name, Int_t max){
- //
- // make profile histrogram of amplitudes
- //
+ /// make profile histrogram of amplitudes
+
TF1 * fline = new TF1("fline","[0]+[1]*[0]*(250-x)");
TF1 * f1 = new TF1("f1","[0]*exp(-[1]*(250-x))");
TProfile *profA = new TProfile(name,name,max,0,250);
}
TProfile * ProfileMaxZ(TCut cut0, char *name, Int_t max){
- //
- // make profile histrogram of amplitudes
- //
+ /// make profile histrogram of amplitudes
+
TF1 * f1 = new TF1("f1","[0]+[1]*[0]*(250-x)");
TProfile *profA = new TProfile(name,name,max,0,250);
char expr[100];
void P3Z(TCut cut0, TCut cut1, char * description){
- //
- // first exponenent as function of z drift
- //
+ /// first exponenent as function of z drift
+
TF1 * f1 = new TF1("fdiff","[0]+[1]/[0]*x");
f1->SetParameter(1,0.2);
f1->SetParameter(0,0.2);
void P5Z(TCut cut0, TCut cut1, char * description){
- //
- // second exponenent as function of z drift
- //
+ /// second exponenent as function of z drift
+
TF1 * f1 = new TF1("fdiff","[0]+[1]/[0]*x");
f1->SetParameter(1,0.2);
f1->SetParameter(0,0.2);
}
TCanvas * NoiseSector(TCut cut0, char * description, Int_t maxrow, Int_t maxpad){
- //
- // draw plots of the noise
- //
+ /// draw plots of the noise
+
TCanvas * c = new TCanvas;
c->Divide(2,1);
c->Draw();
+/// \file TestSimDigits.C
+
void TestSimDigits() {
AliSimDigits dig;
dig.Allocate(10,10);
* provided "as is" without express or implied warranty. *
**************************************************************************/
+/// \class TestTPCTrackHits
/// Macro to compare TClonesArray hits with interpolated hits
-/// ConvertHits1 read
+/// ConvertHits1 read
///
/// \author MI
void CompareHits(const char * benchmark, Bool_t debug)
{
- //compare persistent hits
+ /// compare persistent hits
+
TFile f2("treeh.root");
TTree * treeh2 = (TTree*)f2.Get("TreeTPCH");
AliTPCTrackHits * myhits = new AliTPCTrackHits ;
void CompareHitsG(const char * benchmark, Bool_t debug)
{
- //compare persistent hits
+ /// compare persistent hits
+
TFile f2("galice.root");
TTree * treeh2 = (TTree*)f2.Get("TreeH0");
AliTPCTrackHits * myhits = new AliTPCTrackHits ;
AliTPCTrackHits * MakeTrack(TClonesArray * arr, TClonesArray * arrp, AliTPCTrackHits *myhits)
{
- //
- //make track wit hits according
+ /// make track wit hits according
+
AliTPChit * hit;
// AliTPCTrackHits * myhits= new AliTPCTrackHits;
myhits->SetHitPrecision(0.002);
void CompareHits(TClonesArray * arr, AliTPCTrackHits * myhits, Bool_t debug, TClonesArray *arrd)
{
- //
- // if debug option kTRUE
- // compare hits and write result to the stdoutput
+ /// if debug option kTRUE
+ /// compare hits and write result to the stdoutput
+
AliTPChit * hit, *hit2;
if (arrd) arrd->Clear();
Double_t fSumX4, Int_t n,
Double_t &a, Double_t &b, Double_t &c)
{
- //
- //recalc parameters not fixing origin point
+ /// recalc parameters not fixing origin point
+
Double_t det =
n* (fSumX2*fSumX4-fSumX3*fSumX3) -
fSumX* (fSumX*fSumX4-fSumX3*fSumX2)+
+/// \class AliTPChitD
+/// \brief Macro to compare TClonesArray hits with interpolated hits
+/// \author MI
+
#ifndef TESTTPCTRACKHITS_H
#define TESTTPCTRACKHITS_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
void ConvertHits(const char * benchmark="0", Bool_t debug=kFALSE);
void CompareHits(const char * benchmark="1", Bool_t debug=kFALSE);
-/// \class AliTPChitD
-/// \brief Macro to compare TClonesArray hits with interpolated hits
-/// \author MI
-
class AliTPChitD : public AliTPChit {
public:
AliTPChit * GetDelta() {return &fDelta;}
+/// \file ViewTPC.C
+
void ViewTPC()
{
gMC->Gsatt("TPC ","SEEN",0);
/// \file recTPC.C
/// \brief Example macro for reconstruction of the TPC raw data
-///
+///
/// The path to the Calibration parameters is for the moment hard-wired in the code
/// Taken from /afs
void recTPC(Int_t type, const char *filename="data.root")
{
- //
- // Set path to calibration data
- //
- // type variable = 0 - cosmic test
- // = 1 - laser test
+ /// 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);
void recTracking(Int_t type, const char *filename="data.root")
{
- //
- // Set path to calibration data
- //
+ /// Set path to calibration data
+
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
man->SetRun(0);
+/// \class template
+
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
static int templ(TVector par, Double_t x, Double_t dy, Double_t dz,
const AliTPCSector *sec, int s, int rf=0)
{
- //-----------------------------------------------------------------
- // This function tries to find a track prolongation.
- //
- // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
- //-----------------------------------------------------------------
+ /// This function tries to find a track prolongation.
+ ///
+ /// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
+
int accepted=0;
const int ROWS_TO_SKIP=100;
int try_again=ROWS_TO_SKIP;
+/// \file testRawReaderFastDDL.C
+///
+/// compare old and new AltroRawStream algorithms for each pad and timebin
+///
+/// check if bins are filled twice (which should not be the case!!!)
+
#include <stdio.h>
#include <TString.h>
#include <TROOT.h>
#include "AliAltroRawStreamFast.h"
#include "AliAltroRawStream.h"
-/*
- compare old and new AltroRawStream algorithms for each pad and timebin
-
- check if bins are filled twice (which should not be the case!!!)
-*/
void testRawReaderFastDDL(const Char_t *file="/data.local/data/06000002142000.1A.root")
{
+/// \file testRawReaderFastTPC.C
+
#include <stdio.h>
#include <TString.h>
#include <TROOT.h>
AliLog::SetGlobalDebugLevel(0) ;
AliLog::SetGlobalLogLevel(AliLog::kFatal);
-// TString filename("/d/alice05/testtpc/raw/pulser/06000002142000.1A.root"); //nfs
-// TString filename("root://lxfs35.gsi.de:1094//alice/testtpc/raw2006/06000001537001.001.root");
+
+ //TString filename("/d/alice05/testtpc/raw/pulser/06000002142000.1A.root"); //nfs
+ //TString filename("root://lxfs35.gsi.de:1094//alice/testtpc/raw2006/06000001537001.001.root");
+
TString filename(file); //local
// on castor: /castor/cern.ch/alice/data/2006/09/18/15/06000002142000.1A.root
+/// \file tpcConvert.C
+
void tpcConvert(){
AliSimulation sim;
sim.ConvertDateToRoot("raw.root","root.root");
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff