virtual void SetMultiplicityBin(Int_t min, Int_t max, Int_t step)
{fMultMin = min; fMultMax = max; fMultStep = step;}
//
- void SetTagDirectory(char* dirname) {fTagDirectory = dirname;};
- virtual Int_t BinNumber() {return fBinNumber;}
+ void SetTagDirectory(const char* dirname) {fTagDirectory = dirname;};
+ virtual Int_t BinNumber() const {return fBinNumber;}
private:
AliEventPoolOTF(const AliEventPoolOTF& obj);
AliLHCTagCuts* fLHCCuts; // LHC cuts
AliDetectorTagCuts* fDetectorCuts; // Detector cuts
AliEventTagCuts* fEventCuts; // Event cuts
- char* fTagDirectory; // Directory with local tag files
+ const char* fTagDirectory; // Directory with local tag files
Int_t fMultMin; // Minimum multiplicity
Int_t fMultMax; // Maximum multiplicity
Int_t fMultStep; // Multiplicity step-size
// these initialisations are needed for a singleton
AliEMCALGeometry *AliEMCALGeometry::fgGeom = 0;
Bool_t AliEMCALGeometry::fgInit = kFALSE;
-Char_t* AliEMCALGeometry::fgDefaultGeometryName = "EMCAL_COMPLETE";
+const Char_t* AliEMCALGeometry::fgDefaultGeometryName = "EMCAL_COMPLETE";
//
// Usage:
// You can create the AliEMCALGeometry object independently from anything.
// General
//
Bool_t IsInitialized(void) const { return fgInit ; }
- static Char_t* GetDefaultGeometryName() {return fgDefaultGeometryName;}
+ static const Char_t* GetDefaultGeometryName() {return fgDefaultGeometryName;}
void PrintGeometry(); //*MENU*
void PrintCellIndexes(Int_t absId=0, int pri=0, char *tit=""); //*MENU*
virtual void Browse(TBrowser* b);
//////////////////////////////////////
// Return EMCAL geometrical parameters
//
- Char_t* GetNameOfEMCALEnvelope() const { Char_t* env = "XEN1"; return env ;}
+ const Char_t* GetNameOfEMCALEnvelope() const { const Char_t* env = "XEN1"; return env ;}
Float_t GetArm1PhiMin() const { return fArm1PhiMin ; }
Float_t GetArm1PhiMax() const { return fArm1PhiMax ; }
Float_t GetArm1EtaMin() const { return fArm1EtaMin;}
//Member data
static AliEMCALGeometry * fgGeom; // pointer to the unique instance of the singleton
static Bool_t fgInit; // Tells if geometry has been succesfully set up.
- static Char_t* fgDefaultGeometryName; // Default name of geometry
+ static const Char_t* fgDefaultGeometryName; // Default name of geometry
TString fGeoName; //geometry name
TObjArray *fArrayOpts; //! array of geometry options
- char *fAdditionalOpts[6]; //! some additional options for the geometry type and name
+ const char *fAdditionalOpts[6]; //! some additional options for the geometry type and name
int fNAdditionalOpts; //! size of additional options parameter
Float_t fECPbRadThickness; // cm, Thickness of the Pb radiators
TGraphErrors *AliEMCALHistoUtilities::DrawGraphErrors(const Int_t n,Double_t *x,Double_t *y,Double_t *ex,
Double_t *ey, Int_t markerColor, Int_t markerStyle, const char* opt, const char* tit,
-const char* xTit,char* yTit, Int_t ifun, const char *optFit, const char *fun)
+const char* xTit,const char* yTit, Int_t ifun, const char *optFit, const char *fun)
{
// Oct 15, 2007
printf("AliEMCALHistoUtilities::drawGraphErrors started \n");
static TGraphErrors *DrawGraphErrors(const Int_t n=4,Double_t *x=0,Double_t *y=0,Double_t *ex=0,
Double_t *ey=0, Int_t markerColor=4,Int_t markerStyle=4, const char* opt="",
const char* tit="", const char* xTit=" jet E_{t} ",
- char* yTit="", Int_t ifun=0, const char *optFit="W+", const char *fun="");
+ const char* yTit="", Int_t ifun=0, const char *optFit="W+", const char *fun="");
// TChain
static void InitChain(TChain *chain=0, const char* nameListOfFiles=0, Int_t nFileMax=0);
static AliRunLoader* InitKinematics(const Int_t nev=0, const char* galiceName="galice.root");
// Define the shape of the Calorimeter
TNode * top = gAlice->GetGeometry()->GetNode("alice") ; // See AliceGeom/Nodes
TNode * envelopNode = 0;
- char *envn = "Envelop1";
+ const char *envn = "Envelop1";
if(gn.Contains("WSUC")) {
envelopNode = BuildGeometryOfWSUC();
} else { // Shish-kebab now for compact and TRD1 cases (ALIC)
top->cd();
TNode *envelopNode = 0;
- char *name = "";
+ const char *name = "";
/*
name = "WSUC";
new TBRIK(name, "WSUC(XEN1 in Geant)","void",fEnvelop1[0],fEnvelop1[1],fEnvelop1[2]);
static TString curVolName;
static int supModuleNumber, moduleNumber, yNumber, xNumber, absid;
static int keyGeom=1; //real TRD1 geometry
- static char *vn = "SCMX"; // Apr 13, 2006 - only TRD1 case now
+ static const char *vn = "SCMX"; // Apr 13, 2006 - only TRD1 case now
static int nSMOP[7]={1,3,5,7,9,11}; // 30-mar-05
static int nSMON[7]={2,4,6,8,10,12};
static Float_t depositedEnergy=0.0;
st += ", zcut, ";
st += name;
- char *optShad = "on", *optHide="on";
+ const char *optShad = "on", *optHide="on";
double cxy=0.02;
if (axis==1) {
dcut = 0.;
// Size of tower is 5.6x5.6x24.8 (25.0); cut on Z axiz
TString sn(GetGeometry()->GetName());
sn.ToUpper();
- char *tit[3]={"xcut", "ycut", "zcut"};
+ const char *tit[3]={"xcut", "ycut", "zcut"};
if(axis<1) axis=1; if(axis>3) axis=3;
gMC->Gsatt("*", "seen", 0);
SetVolumeAttributes(name, 1, 5, fill); // yellow
double cxy=0.055, x0=10., y0=10.;
- char *optShad = "on", *optHide="on";
+ const char *optShad = "on", *optHide="on";
SetVolumeAttributes("STPL", 1, 3, fill); // green
if (axis==1) {
gMC->Gsatt("STPL", "seen", 0);
// See ~/macros/ALICE/sim.C for choice of CDB
// Get calib. table which was used than calculated rec.points
//
- static char *calibType = "EMCAL/Calib/*";
- static char *calibTypeData = "EMCAL/Calib/Data";
+ static const char *calibType = "EMCAL/Calib/*";
+ static const char *calibTypeData = "EMCAL/Calib/Data";
// Initial cc
calData[0] = 0;
Int_t firstRun = 0;
Int_t lastRun = 10;
Int_t beamPeriod = 1;
- char* objFormat = "";
+ const char* objFormat = "";
caldata = new AliEMCALCalibData("EMCAL");
caldata->SetTitle(coment);
AliEMCALFolder* AliEMCALPi0Calibration::fgEMCAL = 0;
AliEMCALFolder* AliEMCALPi0Calibration::fgEMCALOld = 0;
-Char_t **AliEMCALPi0Calibration::fgAnaOpt=0;
+const Char_t **AliEMCALPi0Calibration::fgAnaOpt=0;
Int_t AliEMCALPi0Calibration::fgNanaOpt = 0;
enum keyOpt{
kCORR1,
//
// Constructor. Initialization of pointers
//
- Char_t *anaOpt[]={
+ const Char_t *anaOpt[]={
"CORR1", // GetCorrectedEnergyForGamma1(Double_t eRec);
"RECALIB",
"IDEAL",
};
fgNanaOpt = sizeof(anaOpt) / sizeof(Char_t*);
- fgAnaOpt = new Char_t*[fgNanaOpt];
+ fgAnaOpt = new const Char_t*[fgNanaOpt];
for(int i=0; i<fgNanaOpt; i++) fgAnaOpt[i] = anaOpt[i];
}
TH1::AddDirectory(1);
Int_t itMax = 10, it=0;
- map <int, char*> indName;
+ map <int, const char*> indName;
indName[0] = "eff.mass";
indName[3] = "mass of #pi_{0}";
indName[4] = "resolution of #pi_{0}";
hErecOverEin->SetMaximum(1.001);
}
Int_t markerColor=1;
- char *fun="", *optFit="";
+ const char *fun="", *optFit="";
TF1 *f = 0;
if(0) {
if(ifun==-5) {
//
static AliEMCALGeometry* fgEmcalGeo; //! pointer to EMCAL geometry
static Int_t fgNmaxCell; //! max number of cells
- static Char_t **fgAnaOpt; //! aray of options
+ static const Char_t **fgAnaOpt; //! aray of options
static Int_t fgNanaOpt; //! number of options
ClassDef(AliEMCALPi0Calibration, 1);
}
Bool_t ret = kFALSE ;
- Char_t * test = "not OK";
- Char_t * test2 = "not OK";
+ const Char_t * test = "not OK";
+ const Char_t * test2 = "not OK";
if(chiSq < chiMax && chiSq > chiLow)
test = "OK" ;
if(mpv > 0.6 && mpv < 1)
test2 = "OK" ;
- if(test == "OK" && test2 == "OK")
+ if(!strcmp(test,"OK") && !strcmp(test2,"OK"))
ret = kTRUE;
- if(test == "not OK" || test2 == "not OK") {
+ if(!strcmp(test,"not OK") || !strcmp(test2,"not OK")) {
AliWarning("Bad fit results") ;
printf("Detector : %s\n", hTest->GetName()) ;
printf("Landau fit Chi Square / NDF = %f / %d which is %s\n", chiSq*ndf, ndf, test) ;
}
//______________________________________________________________________________
-const int AliTRDQATask::GetSector(const double alpha) const
+int AliTRDQATask::GetSector(const double alpha) const
{
// Gets the sector number
}
//______________________________________________________________________________
-const int AliTRDQATask::CheckSector(const int sector) const
+int AliTRDQATask::CheckSector(const int sector) const
{
// Checks the sector number
const int knSec = 8;
private:
- const int GetSector(const double alpha) const;
- const int CheckSector(const int sector) const;
+ int GetSector(const double alpha) const;
+ int CheckSector(const int sector) const;
void CalculateEff();
void DrawESD() const ;
void DrawGeoESD() const ;
SetLineWidth(2);
}
- Char_t *model = "line";
+ const Char_t *model = "line";
if(!TESTBIT(s, kTrackCosmics)){
if(TESTBIT(s, kTrackModel)) model = "kalman";
else model = "rieman";
Resize(GetDefaultSize());
MapWindow();
- char *title[] = {"MC loader", "Single file loader", "Raw data loader"};
+ const char *title[] = {"MC loader", "Single file loader", "Raw data loader"};
// char *color[] = {"#ff0000", "#0000ff", "#59d454"};
int id = fSelector->GetSelected(), type;
switch(id){
fCombo->Connect("Selected(Int_t)", "AliEveTRDMacroWizzard", this, "Create(Int_t)");
}
-Char_t *fIncludes =
+const Char_t *fIncludes =
"#if !defined(__CINT__) || defined(__MAKECINT__)\n"
"#include <TROOT.h>\n"
"#include <TH1.h>\n"
"#include <TRD/AliTRDtrackV1.h>\n"
"#endif\n";
-Char_t *fMacroTemplate[7] = {
+const Char_t *fMacroTemplate[7] = {
""
," if (!track) return kFALSE;\n"
typedef void (*CompileInfo)( char*& date, char*& time);
CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(*library, "CompileInfo");
if (fctInfo) {
- char* date="";
- char* time="";
+ char* date=0;
+ char* time=0;
(*fctInfo)(date, time);
- if (!date) date="unknown";
- if (!time) time="unknown";
+ if (!date) {date=new Char_t[8]; strcpy(date,"unknown");}
+ if (!time) {time=new Char_t[8]; strcpy(time,"unknown");}
//HLTInfo("%s build on %s (%s)", *library, date, time);
} else {
//HLTInfo("no build info available for %s", *library);
DeleteArray();
}
-void AliHLTTPCMerger::InitMerger(Int_t ntrackarrays,Char_t *tracktype)
+void AliHLTTPCMerger::InitMerger(Int_t ntrackarrays,const Char_t *tracktype)
{
//Used to setup all arrays
AliHLTTPCVertex *fVertex; //!
Bool_t f2Global; //global
Bool_t Is2Global(Bool_t is){f2Global=is;return f2Global;}
- void InitMerger(Int_t ntrackarrays,Char_t *tracktype="AliHLTTPCTrack");
+ void InitMerger(Int_t ntrackarrays,const Char_t *tracktype="AliHLTTPCTrack");
private:
/** copy constructor prohibited */
SetSize(ntrack);
}
-AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
+AliHLTTPCTrackArray::AliHLTTPCTrackArray(const char* tracktype,Int_t ntrack)
:
fTrackType('t'),
fSize(0),
SetSize(ntrack);
}
-AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
+AliHLTTPCTrackArray::AliHLTTPCTrackArray(const char* tracktype)
:
fTrackType('t'),
fSize(0),
* - AliHLTTPCModelTrack -> 'm'
* @param ntrack initial size
*/
- AliHLTTPCTrackArray(char* tracktype,Int_t ntrack);
+ AliHLTTPCTrackArray(const char* tracktype,Int_t ntrack);
/**
* constructor
* @param tracktype string describing type, one of
* - AliHLTTPCHoughTrack -> 'h'
* - AliHLTTPCModelTrack -> 'm'
*/
- AliHLTTPCTrackArray(char* tracktype);
+ AliHLTTPCTrackArray(const char* tracktype);
/** destructor */
virtual ~AliHLTTPCTrackArray();
void AliHMPIDHit::Print(Option_t *opt)const
{
//Print hit
- char *sPart=Form("pid=%i",Pid());
+ const char *sPart=Form("pid=%i",Pid());
switch(Pid()){
case kProton: sPart="p+ ";break;
case kProtonBar: sPart="p- ";break;
Int_t PadPcX ( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2X(GetPad(ddl,row,dil,pad));} //pad pc x # 0..79
Int_t PadPcY ( Int_t ddl,Int_t row,Int_t dil,Int_t pad ) {return AliHMPIDParam::A2Y(GetPad(ddl,row,dil,pad));} //pad pc y # 0..47
- static inline Char_t* GetErrName(Int_t eType);
+ static inline const Char_t* GetErrName(Int_t eType);
inline Bool_t SetZeroSup (Bool_t isSup);
inline Bool_t GetZeroSup()const;
inline Int_t GetErrors(Int_t ddl,Int_t eType)const; //Get errors and occurance
else return fNumOfErr[ddl][eType];
} //GetErrors()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Char_t* AliHMPIDRawStream::GetErrName(Int_t eType)
+const Char_t* AliHMPIDRawStream::GetErrName(Int_t eType)
{
// Return the name of the error for a given error tye during raw data reading
// Arguments: errorType
// Returns: error or -999 if error Type does not exist
- Char_t *eName[]={ "kRawDataSizeErr", "kRowMarkerErr" , "kWrongRowErr" , "kWrongDilogicErr",
+ const Char_t *eName[]={ "kRawDataSizeErr", "kRowMarkerErr" , "kWrongRowErr" , "kWrongDilogicErr",
"kWrongPadErr" , "kEoEFlagErr" , "kEoESizeErr" , "kEoEDILOGICErr",
"kEoERowErr" , "kBadSegWordErr", "kWrongSegErr" , "kRowMarkerSizeErr",
"kPedQZero" , "kSumErr" };
- Char_t *eNoErr="NotDefinedErrorType";
+ const Char_t *eNoErr="NotDefinedErrorType";
if(eType<0 || eType>kSumErr) return eNoErr;
else return eName[eType];
}//GetErrName()
}//CreateCradle()
-TGeoVolume * AliHMPIDv3::CradleBaseVolume(TGeoMedium *med, Double_t l[7],char *name)
+TGeoVolume * AliHMPIDv3::CradleBaseVolume(TGeoMedium *med, Double_t l[7],const char *name)
{
/*
The trapezoid is build in the xy plane
static void TestGeom ( ); //tests the validity of geometry
static void TestPoint (Int_t ch,Float_t x,Float_t y ); //tests the validity of geometry
TGeoVolume* CreateChamber (Int_t number ); //chamber geometry building
- TGeoVolume* CradleBaseVolume ( TGeoMedium *med, Double_t l[7], char *name); //base topology of the cradle elements
+ TGeoVolume* CradleBaseVolume ( TGeoMedium *med, Double_t l[7], const char *name); //base topology of the cradle elements
TGeoVolume* CreateCradle ( ); //cradle geometry building
protected:
enum EMedia {kAir=1,kRoha=2,kSiO2=3,kC6F14=4,kCH4=5,kCsI=6,kAl=7,kCu=8,kW=9,kNeo=10,kAr=11}; //media ids, used for geometry creation
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
const Char_t *det[3] = {"SPD","SDD","SSD"};
- Char_t* digclass;
+ const Char_t* digclass;
Int_t buffersize = 4000;
Char_t branchname[30];
const char *det[4] = {"SPD","SDD","SSD","ITS"};
TBranch *branch;
- Char_t* digclass;
+ const Char_t* digclass;
Int_t i;
char branchname[30];
else return 1.;
}
- virtual void SetDigitClassName(Int_t i,Char_t *digit)
+ virtual void SetDigitClassName(Int_t i,const Char_t *digit)
{fDigClassName[i]=digit;}
- virtual void SetClusterClassName(Int_t i,Char_t *cluster)
+ virtual void SetClusterClassName(Int_t i,const Char_t *cluster)
{fClusterClassName[i]=cluster;}
- virtual void SetRecPointClassName(Int_t i,Char_t *recpoint)
+ virtual void SetRecPointClassName(Int_t i,const Char_t *recpoint)
{fRecPointClassName[i]=recpoint;}
virtual void SetLoadOnlySPDCalib(Bool_t opt=kFALSE)
{fLoadOnlySPDCalib=opt;}
- Char_t* GetDigitClassName(Int_t i) const {return fDigClassName[i];}
- Char_t* GetClusterClassName(Int_t i) const {return fClusterClassName[i];}
- Char_t* GetRecPointClassName(Int_t i) const {return fRecPointClassName[i];}
+ const Char_t* GetDigitClassName(Int_t i) const {return fDigClassName[i];}
+ const Char_t* GetClusterClassName(Int_t i) const {return fClusterClassName[i];}
+ const Char_t* GetRecPointClassName(Int_t i) const {return fRecPointClassName[i];}
TObjArray* GetDigits() const {return fDigits;}
Int_t *Ndtype() {return fNdtype;}
Float_t fAveGainSDD; //! Average gain of SDD good anodes
Bool_t fIsHLTmodeC; //! flag for HLT mode C status (used by SDD)
Int_t *fNdtype; //! detector types
- Char_t* fClusterClassName[3]; //! String with Cluster class name
- Char_t* fDigClassName[3]; //! String with digit class name.
- Char_t* fRecPointClassName[3];//! String with RecPoint class name
+ const Char_t* fClusterClassName[3]; //! String with Cluster class name
+ const Char_t* fDigClassName[3]; //! String with digit class name.
+ const Char_t* fRecPointClassName[3];//! String with RecPoint class name
TObjArray *fCtype; //! List of clusters
Int_t *fNctype; //[fNDetTypes] Num. of clust. per type of det.
}
}
//___________________________________________________________________
-void AliITSDetTypeSim::SetTreeAddressS(TTree* treeS, Char_t* name){
+void AliITSDetTypeSim::SetTreeAddressS(TTree* treeS, const Char_t* name){
// Set branch address for the ITS summable digits Trees.
char branchname[30];
}
//___________________________________________________________________
-void AliITSDetTypeSim::SetTreeAddressD(TTree* treeD, Char_t* name){
+void AliITSDetTypeSim::SetTreeAddressD(TTree* treeD, const Char_t* name){
// Set branch address for the digit Trees.
const char *det[3] = {"SPD","SDD","SSD"};
fDigits = new TObjArray(fgkNdettypes);
}
for(Int_t i=0;i<fgkNdettypes;i++){
- Char_t* digclass = GetDigitClassName(i);
+ const Char_t* digclass = GetDigitClassName(i);
if(digclass==0x0){
if(i==0) SetDigitClassName(i,"AliITSdigitSPD");
if(i==1) SetDigitClassName(i,"AliITSdigitSDD");
virtual void SetDefaultSimulation();
virtual void SetRunNumber(Int_t rn=0){fRunNumber = rn;}
virtual Int_t GetRunNumber() const {return fRunNumber;}
- virtual void SetTreeAddressS(TTree* treeS, Char_t* name);
- virtual void SetTreeAddressD(TTree* treeD, Char_t* name);
+ virtual void SetTreeAddressS(TTree* treeS, const Char_t* name);
+ virtual void SetTreeAddressD(TTree* treeD, const Char_t* name);
virtual void SetDigits(TObjArray* digits) {fDigits=digits;}
const TClonesArray* GetSDigits() const { return &fSDigits;}
virtual void ResetSDigits(){fNSDigits=0; fSDigits.Clear();}
virtual void ResetDigits();
virtual void ResetDigits(Int_t branch);
- virtual void SDigitsToDigits(Option_t *opt,Char_t* name);
+ virtual void SDigitsToDigits(Option_t *opt, Char_t* name);
virtual void AddSumDigit(AliITSpListItem &sdig);
virtual void AddSimDigit(Int_t branch, AliITSdigit *d);
virtual void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
Int_t* tracks,Int_t *hits,Float_t* trkcharges,
Int_t sigexpanded=-1000);
- virtual void SetDigitClassName(Int_t i, Char_t* name) {
+ virtual void SetDigitClassName(Int_t i, const Char_t* name) {
fDigClassName[i]=name;}
- Char_t* GetDigitClassName(Int_t i) const {return fDigClassName[i];}
+ const Char_t* GetDigitClassName(Int_t i) const {return fDigClassName[i];}
void StoreCalibration(Int_t firstRun, Int_t lastRun, AliCDBMetaData &md);
protected:
AliITSDDLModuleMapSDD *fDDLMapSDD; //! mapping DDL/module -> SDD module number
TString fHitClassName; //! String with Hit class name
TString fSDigClassName;//! String with SDigit class name.
- Char_t* fDigClassName[3]; //! String with digit class name.
+ const Char_t* fDigClassName[3]; //! String with digit class name.
AliITSLoader* fLoader; //! loader
Bool_t fFirstcall; //! flag
Bool_t fIsHLTmodeC; //! flag for HLT mode C status (used by SDD)
const AliITSDetector kIdet[6] = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
const TString kPathbase = "/ALIC_1/ITSV_1/";
- char *pathSPDsens1, *pathSPDsens2;
+ const char *pathSPDsens1, *pathSPDsens2;
if (SPDIsTGeoNative()) {
pathSPDsens1="%sITSSPD_1/ITSSPDCarbonFiberSectorV_%d/ITSSPDSensitiveVirtualvolumeM0_1/ITSSPDlay1-Stave_%d/ITSSPDhalf-Stave%d_1/ITSSPDlay1-Ladder_%d/ITSSPDlay1-sensor_1";
pathSPDsens2="%sITSSPD_1/ITSSPDCarbonFiberSectorV_%d/ITSSPDSensitiveVirtualvolumeM0_1/ITSSPDlay2-Stave_%d/ITSSPDhalf-Stave%d_1/ITSSPDlay2-Ladder_%d/ITSSPDlay2-sensor_1";
pathSPDsens2 = "%sITSD_1/IT12_1/I12B_%d/I20B_%d/L2H-STAVE%d_1/I1D7_%d/I1D1_1/ITS2_1";
}
- char *pathSDDsens1, *pathSDDsens2;
+ const char *pathSDDsens1, *pathSDDsens2;
if (SDDIsTGeoNative()) {
pathSDDsens1 = "%sITSsddLayer3_1/ITSsddLadd_%d/ITSsddSensor3_%d/ITSsddWafer3_%d/ITSsddSensitivL3_1";
pathSDDsens2 = "%sITSsddLayer4_1/ITSsddLadd_%d/ITSsddSensor4_%d/ITSsddWafer4_%d/ITSsddSensitivL4_1";
pathSDDsens2 = "%sITSD_1/IT34_1/I005_%d/I402_%d/ITS4_%d";
}
- char *pathSSDsens1, *pathSSDsens2;
+ const char *pathSSDsens1, *pathSSDsens2;
if (SSDIsTGeoNative()) {
pathSSDsens1 = "%sITSssdLayer5_1/ITSssdLay5Ladd_%d/ITSssdSensor5_%d/ITSssdSensitivL5_1";
pathSSDsens2 = "%sITSssdLayer6_1/ITSssdLay6Ladd_%d/ITSssdSensor6_%d/ITSssdSensitivL6_1";
for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
new TVector3((GetReflection(vertexposition[0][j],param))->X(),
(GetReflection(vertexposition[0][j],param))->Y());
- char* carbonfibersupportshapename[kshapesnumber] =
+ const char* carbonfibersupportshapename[kshapesnumber] =
{"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
- char* carbonfibersupportname[kshapesnumber] =
+ const char* carbonfibersupportname[kshapesnumber] =
{"CarbonFiberSupport1","CarbonFiberSupport2"};
TGeoArb8* carbonfibersupportshape[kshapesnumber];
TGeoVolume* carbonfibersupport[kshapesnumber];
vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
fgkCarbonFiberLowerSupportVolumePosition[1]);
- char* carbonfiberlowersupportshapename[kshapesnumber] =
+ const char* carbonfiberlowersupportshapename[kshapesnumber] =
{"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
- char* carbonfiberlowersupportname[kshapesnumber] =
+ const char* carbonfiberlowersupportname[kshapesnumber] =
{"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
TGeoVolume* carbonfiberlowersupport[kshapesnumber];
}
Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
{fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
- char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
+ const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
{"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
Double_t radiusmax,
Double_t width,
Int_t ncables,
- char* volname){
+ const char* volname){
/////////////////////////////////////////////////////////////
// Generating EndCap High Voltage Tubes
/////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////
TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
- Double_t height, char* shapename, Int_t isign) const{
+ Double_t height, const char* shapename, Int_t isign) const{
/////////////////////////////////////////////////////////////
// Method generating an Arb shape
/////////////////////////////////////////////////////////////
TGeoVolume** EndCapSupport(); // End Cap Support Layer 5 and Layer 6
void SetEndCapSupportAssembly(); // EndCap Support + End Cap Layer 5 and 6
TGeoVolume* GetEndCapEffectiveCables(Double_t radiusmin, Double_t radiusmax,
- Double_t width,Int_t ncables,char* volname); // End Cap Effective HV Cables
+ Double_t width,Int_t ncables,const char* volname); // End Cap Effective HV Cables
TGeoXtru* GetArcShape(Double_t phi, Double_t rmin,
Double_t rmax, Int_t nedges, Double_t height);
//Auxiliary Method for Arc Shape
TGeoArb8* GetArbShape(TVector3* vertexpos[],Double_t* width,
- Double_t height,char* shapename,Int_t isign = 1) const;
+ Double_t height,const char* shapename,Int_t isign = 1) const;
// Method generating an Arb shape
TGeoShape* GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const;// Method Generating the Screw Shape
TGeoShape* GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const;// Method Generating the Hole Shape
} // end for i
if(GetDebug(1)) for(i=0;i<kct24Ntrays;i++) Info("ServicesCableSupport",
"tha[%d]=%f",i,tha[i]);
- Char_t *airName[kct24Ntrays]={"FMD0","SDD0","SSD0","SSD1","SPD0","SPD1",
+ const Char_t *airName[kct24Ntrays]={"FMD0","SDD0","SSD0","SSD1","SPD0","SPD1",
"TV00","SDD1","SDD2","SPD2","SPD3","ALG0",
"SPD4","SPD5","SSD2","SSD3","SPD6","SPD7",
"TV01","SDD3","SDD4","SPD8","SPD9","ALG1",
"TV02","SDD6","SDD7","SPDC","SPDD","ALG2",
"SPDE","SPDF","SSD6","SSD7","SPDG","SPDH",
"TV03","SDD8","SDD9","SPDI","SPDJ","ALG3"};
- Char_t *trayName[kct24Ntrays]={"FMD0","SSD0","SSD1","SSD2","SSD3","SPD0",
+ const Char_t *trayName[kct24Ntrays]={"FMD0","SSD0","SSD1","SSD2","SSD3","SPD0",
"TV00","SDD0","SDD1","SDD2","SPD1","ALG0",
"SPD2","SSD4","SSD5","SSD6","SSD7","SPD3",
"TV01","SDD3","SDD4","SDD5","SPD4","ALG1",
thb[i+ kft24NPatchPannels/2] = 180.0 + thb[i];
thb[i+3*kft24NPatchPannels/4] = 270.0 + thb[i];
} // end for i
- Char_t *pachName[kft24NPatchPannels]={"FMD0","SSD0","SPD0","SDD0","SPD1",
+ const Char_t *pachName[kft24NPatchPannels]={"FMD0","SSD0","SPD0","SDD0","SPD1",
"SPD2","SSD1","SPD3","SDD1","SPD4",
"FMD1","SSD2","SPD5","SDD2","SPD6",
"SPD7","SSD3","SPD8","SDD3","SPD9"};
Float_t a,z,dens,radl,absl;
Float_t* ubuf=0; Int_t nbuf;
- char* ssss="";
+ char* ssss=0;
gMC->Gfmate(idtmed[fTarg],ssss,a,z,dens,radl,absl,ubuf,nbuf);
Info("CreateGeometry","Target A=%f, Z=%f, dens=%f",a,z,dens);
fReaderHeader(0x0),
fDirectory(0x0),
fBkgdDirectory(0x0),
- fFile(0x0),
+ fFile("anaJets.root"),
fEventMin(0),
fEventMax(-1),
fRunMin(0),
fPtEneH(0)
{
// Default constructor
- fFile = "anaJets.root";
// initialize weight for dE/dr histo
SetdEdrWeight();
{fDirectory = directory;} // directory where file with jets is
void SetBkgdDirectory(char* directory)
{fBkgdDirectory = directory;} // directory where file with background is
- void SetOutputFile(char* file) {fFile = file;} // file where plots will be saved
+ void SetOutputFile(const char* file) {fFile = file;} // file where plots will be saved
void SetPercentage(Float_t p) {fPercentage = p;} // minimum percentage of tracks coming from pythia (very aprox.)
void SetEventRange(Int_t imin, Int_t imax)
{fEventMin = imin; fEventMax = imax;} // first and last event
char* fReaderHeader; // Reader header
char* fDirectory; // Directory
char* fBkgdDirectory; // Directory for background
- char* fFile; // Output file name
+ const char* fFile; // Output file name
Int_t fEventMin; // Minimum event number
Int_t fEventMax; // Maximum event number
Int_t fRunMin; // Minimum run number
AliJetDistributions::AliJetDistributions():
fReaderHeader(0x0),
fDirectory(0x0),
- fFile(0x0),
+ fFile("jets.root"),
fEventMin(0),
fEventMax(-1),
fRunMin(0),
fMultH(0)
{
// Default constructor
- fFile = "jets.root";
SetReaderHeader();
}
// Setter
void SetDirectory(char* directory) {fDirectory = directory;}
- void SetOutputFile(char* file) {fFile = file;}
+ void SetOutputFile(const char* file) {fFile = file;}
void SetPercentage(Float_t p) { fPercentage = p;}
void SetEventRange(Int_t imin, Int_t imax) {fEventMin = imin; fEventMax = imax;}
void SetRunRange(Int_t imin, Int_t imax) {fRunMin = imin; fRunMax = imax;}
void SetPythia(Bool_t f = kFALSE){fPythia = f;}
void SetProperties(TH1* h,const char* x, const char* y) const;
- void SetReaderHeader(char *s="AliJetKineReaderHeader") {fReaderHeader = s;}
+ void SetReaderHeader(const char *s="AliJetKineReaderHeader") {fReaderHeader = s;}
void SetPartPtCut(Float_t c) { fPartPtCut = c; }
void SetDoLeadPart(Bool_t f = kTRUE) {fDoPart = f;}
private:
char* fReaderHeader;// Reader header
char* fDirectory; // Directory
- char* fFile ; // Output file name
+ const char* fFile ; // Output file name
Int_t fEventMin; // Minimum event number
Int_t fEventMax; // Maximum event number
Int_t fRunMin; // Minimum run number
AliJetDummyGeo(const AliJetDummyGeo& geom);
virtual ~AliJetDummyGeo();
static AliJetDummyGeo* GetInstance() {return new AliJetDummyGeo();}
- static AliJetDummyGeo* GetInstance(char* /*name*/, char* /*title*/)
+ static AliJetDummyGeo* GetInstance(const char* /*name*/, const char* /*title*/)
{return new AliJetDummyGeo();}
- Char_t* GetNameOfEMCALEnvelope() const {return "XEN1";}
+ const Char_t* GetNameOfEMCALEnvelope() const {return "XEN1";}
Float_t GetEnvelop(Int_t index) const { return fEnvelop[index];}
Float_t AngleFromEta(Float_t eta) const {
// returns theta in radians for a given pseudorapidity
}
//___________________________________________
-UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres)
+UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, const char *thres)
{
/// global trigger algorithm
/// a ,b = reg response = Hpt (+|-|us|ls) | Lpt (+|-|us|ls)
virtual void Response();
/// response of the algorithm
- virtual UShort_t Algo(UShort_t i, UShort_t j, char *thres);
+ virtual UShort_t Algo(UShort_t i, UShort_t j, const char *thres);
/// Reset regional board responses
virtual void Reset() {for (Int_t i=0; i<16; i++) fRegionalResponse[i] = 0;}
printf("===============================================================\n");
printf(" 5432109876543210");
- char *x[4] = {"XMC11","XMC12","XMC21","XMC22"};
- char *s[4] = {" ",
+ const char *x[4] = {"XMC11","XMC12","XMC21","XMC22"};
+ const char *s[4] = {" ",
" ",
" ",
" "};
Int_t lL = atoi(&l[4]), cC = atoi(&l[2]), sS = (copy=='R') ? +1 : -1;
- char *b[4] = {"12", "34", "56", "78"};
+ const char *b[4] = {"12", "34", "56", "78"};
Int_t ib = 0;
}
//___________________________________________
-UShort_t AliMUONRegionalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres, Int_t level)
+UShort_t AliMUONRegionalTriggerBoard::Algo(UShort_t i, UShort_t j, const char *thres, Int_t level)
{
/// implementation of the regional algorithm
/// similar to the global algorithm except for the
virtual void SetLocalResponse(UShort_t val[16]) {for (Int_t i=0;i<16;i++) fLocalResponse[i] = val[i];}
/// response of the algorithm
- virtual UShort_t Algo(UShort_t i, UShort_t j, char *thres, Int_t level);
+ virtual UShort_t Algo(UShort_t i, UShort_t j, const char *thres, Int_t level);
/// set local boards enable
void Mask(UShort_t mask);
}
-Double_t AliMUONSurveyObj::EvalFunction(TF2 *lFunction, Int_t iP1, Int_t iP2, Char_t *lCoord) {
+Double_t AliMUONSurveyObj::EvalFunction(TF2 *lFunction, Int_t iP1, Int_t iP2, const Char_t *lCoord) {
if (!lFunction) {
AliError("No function given!!!");
AliMUONSurveyUtil *surveyUtil = AliMUONSurveyUtil::Instance();
// Xcenter functions
- char *fxcName = "fXcn00";
+ const char *fxcName = "fXcn00";
TF2 **fXc = new TF2*[2];
fxcName = "fXcn";
fXc[0] = new TF2(fxcName,surveyUtil,&AliMUONSurveyUtil::xnCenter,fXMin,fXMax,fYMin,fYMax,7,"AliMUONSurveyUtil","xnCenter");
fXc[1] = new TF2(fxcName,surveyUtil,&AliMUONSurveyUtil::xpCenter,fXMin,fXMax,fYMin,fYMax,7,"AliMUONSurveyUtil","xpCenter");
// Ycenter functions
- char *fycName = "fYcn00";
+ const char *fycName = "fYcn00";
TF2 **fYc = new TF2*[2];
fycName = "fYcn";
fYc[0] = new TF2(fycName,surveyUtil,&AliMUONSurveyUtil::ynCenter,fYMin,fYMax,fYMin,fYMax,8,"AliMUONSurveyUtil","ynCenter");
fYc[1] = new TF2(fycName,surveyUtil,&AliMUONSurveyUtil::ypCenter,fYMin,fYMax,fYMin,fYMax,8,"AliMUONSurveyUtil","ypCenter");
// Zcenter functions
- char *fzcName = "fZcn00";
+ const char *fzcName = "fZcn00";
TF2 **fZc = new TF2*[2];
fzcName = "fZcn";
fZc[0] = new TF2(fzcName,surveyUtil,&AliMUONSurveyUtil::znCenter,fZMin,fZMax,fZMin,fZMax,8,"AliMUONSurveyUtil","znCenter");
fZc[1] = new TF2(fzcName,surveyUtil,&AliMUONSurveyUtil::zpCenter,fZMin,fZMax,fZMin,fZMax,8,"AliMUONSurveyUtil","zpCenter");
// Phi rotation using xglobal coords functions
- char *fphixName = "fPhiXnn00";
+ const char *fphixName = "fPhiXnn00";
TF2 ***fPhiX = new TF2**[2];
for (Int_t iX =0; iX<2; iX++) {
fPhiX[iX] = new TF2*[2];
fPhiX[1][1] = new TF2(fphixName,surveyUtil,&AliMUONSurveyUtil::phixpp,fXMin,fXMax,fXMin,fXMax,7,"AliMUONSurveyUtil","phixpp");
// Phi rotation using yglobal coords functions
- char *fphiyName = "fPhiYnn00";
+ const char *fphiyName = "fPhiYnn00";
TF2 ***fPhiY = new TF2**[2];
for (Int_t iY =0; iY<2; iY++) {
fPhiY[iY] = new TF2*[2];
Int_t SurveyToAlign(Double_t psi=0., Double_t tht=0., Double_t epsi=0., Double_t etht=0.);
Double_t SurveyChi2(Double_t *par);
- Double_t EvalFunction(TF2 *lFunction, Int_t iP1, Int_t iP2, Char_t *lCoord);
+ Double_t EvalFunction(TF2 *lFunction, Int_t iP1, Int_t iP2, const Char_t *lCoord);
void CalculateTranslation(TF2 *xFunc, TF2 *yFunc, TF2 *zFunc, Int_t iP1, Int_t iP2, Double_t *lCenTemp);
// TGeoCombiTrans *CalculateTransformation(TF2 *xFunc, TF2 *yFunc, TF2 *zFunc, TF2 *pFunc, Int_t iP1, Int_t iP2);
THijing THbtp EMCAL HBTAN \
THerwig TEPEMGEN FASTSIM TPHIC RAW MONITOR ANALYSIS \
JETAN HLT LHC ESDCheck STAT TTherminator CORRFW DPMJET TDPMjet \
- PWG0 PWG1 PWG2 PWG3 PWG4
+ PWG0 PWG1 PWG2 PWG3 PWG4 UNICOR
ifneq ($(shell $(ROOTCONFIG) --has-pythia8), no)
ALIROOTMODULES += PYTHIA8
virtual Long64_t Merge(TCollection* list);
- AliCorrectionMatrix2D* GetEventCorrection() { return fEventCorr; }
- AliCorrectionMatrix3D* GetTrackCorrection() { return fTrackCorr; }
+ AliCorrectionMatrix2D* GetEventCorrection() const { return fEventCorr; }
+ AliCorrectionMatrix3D* GetTrackCorrection() const { return fTrackCorr; }
void SetEventCorrection(AliCorrectionMatrix2D* corr) { fEventCorr = corr; }
void SetTrackCorrection(AliCorrectionMatrix3D* corr) { fTrackCorr = corr; }
}
//____________________________________________________________________
-TH1* AliCorrectionMatrix2D::Get1DCorrectionHistogram(Char_t* opt, Float_t min, Float_t max)
+TH1* AliCorrectionMatrix2D::Get1DCorrectionHistogram(const Char_t* opt, Float_t min, Float_t max)
{
//
// integrate the correction over one variable
TH2* GetCorrectionHistogram() {return (TH2*)fhCorr;}
- TH1* Get1DCorrection(Char_t* opt="x", Float_t min=0, Float_t max=0) {return Get1DCorrectionHistogram(opt,min,max);}
- TH1* Get1DCorrectionHistogram(Char_t* opt="x", Float_t min=0, Float_t max=0);
+ TH1* Get1DCorrection(const Char_t* opt="x", Float_t min=0, Float_t max=0) {return Get1DCorrectionHistogram(opt,min,max);}
+ TH1* Get1DCorrectionHistogram(const Char_t* opt="x", Float_t min=0, Float_t max=0);
void Rebin(Int_t x = 1, Int_t y = 1);
}
//____________________________________________________________________
-AliCorrectionMatrix2D* AliCorrectionMatrix3D::Get2DCorrection(Char_t* opt, Float_t aMin, Float_t aMax)
+AliCorrectionMatrix2D* AliCorrectionMatrix3D::Get2DCorrection(Option_t* opt, Float_t aMin, Float_t aMax)
{
// returns a 2D projection of this correction
}
//____________________________________________________________________
-TH1* AliCorrectionMatrix3D::Get1DCorrectionHistogram(Char_t* opt, Float_t aMin1, Float_t aMax1, Float_t aMin2, Float_t aMax2)
+TH1* AliCorrectionMatrix3D::Get1DCorrectionHistogram(Option_t* opt, Float_t aMin1, Float_t aMax1, Float_t aMin2, Float_t aMax2)
{
// returns a 1D projection of this correction
AliDebug(AliLog::kWarning, Form("WARNING: test"));
TH3* GetMeasuredHistogram();
TH3* GetCorrectionHistogram();
- AliCorrectionMatrix2D* Get2DCorrection(Char_t* opt, Float_t aMin, Float_t aMax);
- TH2* Get2DCorrectionHistogram(Char_t* opt, Float_t aMin, Float_t aMax) {return Get2DCorrection(opt,aMin,aMax)->GetCorrectionHistogram();}
- TH1* Get1DCorrectionHistogram(Char_t* opt, Float_t aMins1=0, Float_t aMax1=0, Float_t aMins2=0, Float_t aMax2=0);
+ AliCorrectionMatrix2D* Get2DCorrection(Option_t* opt, Float_t aMin, Float_t aMax);
+ TH2* Get2DCorrectionHistogram(Option_t* opt, Float_t aMin, Float_t aMax) {return Get2DCorrection(opt,aMin,aMax)->GetCorrectionHistogram();}
+ TH1* Get1DCorrectionHistogram(Option_t* opt, Float_t aMins1=0, Float_t aMax1=0, Float_t aMins2=0, Float_t aMax2=0);
void FillMeas(Float_t ax, Float_t ay, Float_t az);
void FillGene(Float_t ax, Float_t ay, Float_t az);
}
//____________________________________________________________________
-const Bool_t AliPWG0Helper::TestVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug)
+Bool_t AliPWG0Helper::TestVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug)
{
// Checks if a vertex meets the needed quality criteria
static Bool_t IsEventTriggered(const AliESD* aEsd, Trigger trigger = kMB2);
static Bool_t IsEventTriggered(ULong64_t triggerMask, Trigger trigger = kMB2);
static const AliESDVertex* GetVertex(AliESDEvent* aEsd, AnalysisMode analysisMethod, Bool_t debug = kFALSE,Bool_t bRedoTPC = false);
- static const Bool_t TestVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug = kFALSE);
+ static Bool_t TestVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug = kFALSE);
static Bool_t IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries, Bool_t adebug = kFALSE);
fhSigmaYProfileZVsRow ->Fill(padRow, z, sigmaY);
fhSigmaZProfileZVsRow ->Fill(padRow, z, sigmaZ);
- if (time>0 & fTimeStart>0 & fTimeStop>0 & time>fTimeStart) {
+ if (time>0 && fTimeStart>0 && fTimeStop>0 && time>fTimeStart) {
//Float_t timeFraction = (time - fTimeStart)/(fTimeStop-fTimeStart);
fhMeanQtotVsTime->Fill(time,qTot);
}
//____________________________________________________________________
-dNdEtaAnalysis::dNdEtaAnalysis(Char_t* name, Char_t* title, AliPWG0Helper::AnalysisMode analysisMode) :
+dNdEtaAnalysis::dNdEtaAnalysis(const Char_t* name, const Char_t* title, AliPWG0Helper::AnalysisMode analysisMode) :
TNamed(name, title),
fData(0),
fMult(0),
enum { kVertexBinning = 1+2 }; // the first is for the whole vertex range, the others divide the vertex range
dNdEtaAnalysis();
- dNdEtaAnalysis(Char_t* name, Char_t* title, AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD);
+ dNdEtaAnalysis(const Char_t* name, const Char_t* title, AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD);
virtual ~dNdEtaAnalysis();
dNdEtaAnalysis(const dNdEtaAnalysis &c);
virtual Long64_t Merge(TCollection* list);
- AliCorrection* GetData() { return fData; }
+ AliCorrection* GetData() const { return fData; }
- TH1F* GetPtHistogram() { return fPtDist; }
+ TH1F* GetPtHistogram() const { return fPtDist; }
- TH1F* GetdNdEtaHistogram(Int_t i = 0) { return fdNdEta[i]; }
- TH1F* GetdNdEtaPtCutOffCorrectedHistogram(Int_t i = 0) { return fdNdEtaPtCutOffCorrected[i]; }
+ TH1F* GetdNdEtaHistogram(Int_t i = 0) const { return fdNdEta[i]; }
+ TH1F* GetdNdEtaPtCutOffCorrectedHistogram(Int_t i = 0) const { return fdNdEtaPtCutOffCorrected[i]; }
void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
TClonesArray* digits = 0;
treeD->SetBranchAddress("ITSDigitsSPD", &digits);
- if (digits);
+ if (digits)
digits->Clear();
// each value for both layers
///////////////////////DIFFERENTIAL FLOW CALCULATIONS////////////////////////
/////////////////////////////////////////////////////////////////////////////
- Double_t X[fgknBins][fgkPmax][fgkQmax]={{0.}};
- Double_t Y[fgknBins][fgkPmax][fgkQmax]={{0.}};
+ Double_t X[fgknBins][fgkPmax][fgkQmax]={{{0.}}};
+ Double_t Y[fgknBins][fgkPmax][fgkQmax]={{{0.}}};
/*
//3D profiles
break;
}
- char *param=0;
+ const char *param=0;
switch (fParameterization){
case kFlat:
param = "Flat";
break;
}
- char *trig=0;
+ const char *trig=0;
switch (fTriggerType){
case kSinglePlusLpt:
trig = "SinglePlusLpt";
}
//______________________________________________________________________________
-Bool_t AliAODEventInfo::IsHeaderAccessible(Char_t *msg) const {
+Bool_t AliAODEventInfo::IsHeaderAccessible(const Char_t *msg) const {
// Tests if the header pointer is set
if(fHe!=0){
return 1;
// AliAODHeader *GetHe() { return (fHe!=0) ? (AliAODHeader*)fHe.GetObject() : 0; }
// AliAODTrack *GetTr();
- Bool_t IsHeaderAccessible(Char_t *msg=0) const;
+ Bool_t IsHeaderAccessible(const Char_t *msg=0) const;
protected:
// Missing in AliAODHeader and added here
Double_t pid[10];
// has to be changed once the muon pid is provided by the ESD
- for (Int_t i = 0; i < 10; pid[i++] = 0.);
+ for (Int_t i = 0; i < 10; pid[i++] = 0.) {}
pid[AliAODTrack::kMuon]=1.;
AliAODHeader* header = AODEvent()->GetHeader();
Int_t nTracks=fOrgAOD->GetNumberOfTracks();
Int_t nMuTracks=0;
Int_t nPosTracks = 0;
- Int_t mutrNumb[10]; for (Int_t i=0; i<10; mutrNumb[i++]=0);
+ Int_t mutrNumb[10]; for (Int_t i=0; i<10; mutrNumb[i++]=0) {}
for (Int_t iTrack=0; iTrack<nTracks; iTrack++){
const Double_t *trackpid=fOrgAOD->GetTrack(iTrack)->PID();
if (trackpid[AliAODTrack::kMuon]==1.) {
Int_t ptBins = 60;
Float_t ptLow = 0., ptHigh = 30.;
- Char_t *ptName = "P_{t} (GeV/c)";
+ const Char_t *ptName = "P_{t} (GeV/c)";
Int_t vzBins = 40;
Float_t vzLow = -20., vzHigh = 20.;
- Char_t *vzName = "Vz (cm)";
+ const Char_t *vzName = "Vz (cm)";
TString baseName, histoName;
fOutputContainer = new TObjArray(fgkNhistos*fgkNTrigCuts);
TString cathCode[2] = {"bendPlane", "nonBendPlane"};
TString countTypeName[2] = {"CountInCh", "NonCountInCh"};
- Char_t* yAxisTitle = "counts";
+ const Char_t* yAxisTitle = "counts";
const Int_t kNboards = 234; //AliMpConstants::NofLocalBoards();
const Int_t kFirstTrigCh = 11;//AliMpConstants::NofTrackingChambers()+1;
Int_t chamberBins = kNchambers;
Float_t chamberLow = kFirstTrigCh-0.5, chamberHigh = kFirstTrigCh+kNchambers-0.5;
- Char_t* chamberName = "chamber";
+ const Char_t* chamberName = "chamber";
Int_t slatBins = kNslats;
Float_t slatLow = 0-0.5, slatHigh = kNslats-0.5;
- Char_t* slatName = "slat";
+ const Char_t* slatName = "slat";
Int_t boardBins = kNboards;
Float_t boardLow = 1-0.5, boardHigh = kNboards+1.-0.5;
- Char_t* boardName = "board";
+ const Char_t* boardName = "board";
TString baseName, histoName;
fList = new TList();
Int_t nbrOfMissCh = newChamber - (oldChamber+1); //!<Number of missing chambers.
CalculMissClusterParam(fTrackParam, oldChamber+1, nbrOfMissCh); //!<Calculation of the parameters of the missing cluster(s).
}
- if ( iTrackParam == nTrackParams - 1 & newChamber != fNCh-1) //!<Check if the last chamber, chamber 9 (from 0 to 9) has responded.
+ if ( iTrackParam == nTrackParams - 1 && newChamber != fNCh-1) //!<Check if the last chamber, chamber 9 (from 0 to 9) has responded.
{
CalculMissClusterParam(fTrackParam, fNCh-1, 1); //!<Calculation of the parameters of the missing cluster(s) in the last chamber.
}
Int_t iDet = 0; //!<Position of the detection element (detElt) in the histograms' list.
if (chamber<4) iDet = detElt-fOffset*(chamber+1)+ 4* chamber ;
- if (chamber>3 & chamber<6) iDet = detElt-fOffset*(chamber+1)+18*(chamber-4)+16;
+ if (chamber>3 && chamber<6) iDet = detElt-fOffset*(chamber+1)+18*(chamber-4)+16;
if (chamber>5) iDet = detElt-fOffset*(chamber+1)+26*(chamber-6)+52;
return iDet;
else //!<For the station 1 & 2 (4 detection elements in each chamber).
{
- if(posX>0 & posY>0) fGetDetElt[0] = fOffset*(chamber+1) ;
- if(posX<0 & posY>0) fGetDetElt[0] = fOffset*(chamber+1) + 1;
- if(posX<0 & posY<0) fGetDetElt[0] = fOffset*(chamber+1) + 2;
- if(posX>0 & posY<0) fGetDetElt[0] = fOffset*(chamber+1) + 3;
+ if(posX>0 && posY>0) fGetDetElt[0] = fOffset*(chamber+1) ;
+ if(posX<0 && posY>0) fGetDetElt[0] = fOffset*(chamber+1) + 1;
+ if(posX<0 && posY<0) fGetDetElt[0] = fOffset*(chamber+1) + 2;
+ if(posX>0 && posY<0) fGetDetElt[0] = fOffset*(chamber+1) + 3;
}
}
vprimary->GetCovarianceMatrix(cov);
Double_t chi2toNDF = vprimary->GetChi2perNDF();
Int_t ncontr=nindices;
- if(vprimary->GetTitle()=="VertexerTracksWithContraint") ncontr += 1;
+ if(!strcmp(vprimary->GetTitle(),"VertexerTracksWithContraint")) ncontr += 1;
Double_t chi2=chi2toNDF*(2.*(Double_t)ncontr-3.);
fV1 = new AliESDVertex(pos,cov,chi2,ncontr,vprimary->GetName());
fV1->SetTitle(vprimary->GetTitle());
AliInfo(Form("!!! All the eps files are in %s.tar.gz !!!", GetName())) ;
- char * report ;
+ const char * report ;
if(problem)
report="Problems found, please check!!!";
else
Int_t fNEvent; //! Number of events in current directory
Int_t fFileNumber; //! Input file number
Int_t fEventsPerFile; //! Number of events per file
- char *fExtension; //! File name extension
+ const Char_t *fExtension; //! File name extension
TString *fPathName; //! Input file path
Bool_t fIsArchive; //! True if directory is an archive
ClassDef(AliESDInputHandlerRP, 1);
// This function books the histograms of *track*residuals*
// as a part of global QA
//------------------------------------------------------
- Char_t *name[]={
+ const Char_t *name[]={
"SPD1 residuals Y","SPD1 residuals Z",
"SPD2 residuals Y","SPD2 residuals Z",
"SDD1 residuals Y","SDD1 residuals Z",
//------------------------------------------------------
{// Cluster related QA
- Char_t *name[]={
+ const Char_t *name[]={
"Fraction of the assigned clusters in ITS",
"Fraction of the assigned clusters in TPC",
"Fraction of the assigned clusters in TRD"
}
{// Track related QA
- Char_t *name[]={
+ const Char_t *name[]={
"Track azimuthal distribution (rad)", // kTrk0
"Track pseudo-rapidity distribution", // kTrk1
"TPC: track momentum distribution (GeV)", // kTrk2
}
{// V0 related QA
- Char_t *name[]={
+ const Char_t *name[]={
"K0s mass (GeV)",
"Lambda0 + Lambda0Bar mass (GeV)"
};
}
{// PID related QA
- Char_t *name[]={
+ const Char_t *name[]={
"ITS: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
"TPC: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
"TOF: tracking - measured (ps)"
Int_t fNEvent; //! Number of events
Int_t fEvent; //! Current event
TString *fPathName; //! Input file path
- char *fExtension; //! File name extension
+ const Char_t *fExtension; //! File name extension
Int_t fFileNumber; //! Input file number
Int_t fEventsPerFile; //! Number of events per file
Bool_t fReadTR; // determines if TR shall be read
ClassImp(AliQADataMakerSteer)
//_____________________________________________________________________________
-AliQADataMakerSteer::AliQADataMakerSteer(char * mode, const char* gAliceFilename, const char * name, const char * title) :
+AliQADataMakerSteer::AliQADataMakerSteer(const Char_t * mode, const Char_t* gAliceFilename, const Char_t * name, const Char_t * title) :
TNamed(name, title),
fCurrentEvent(0),
fCycleSame(kFALSE),
class AliQADataMakerSteer: public TNamed {
public:
- AliQADataMakerSteer(char * mode, const char* gAliceFilename = "galice.root",
- const char * name = "AliQADataMakerSteer",
- const char * title = "QA makers") ;
+ AliQADataMakerSteer(const Char_t * mode, const Char_t * gAliceFilename = "galice.root",
+ const Char_t * name = "AliQADataMakerSteer",
+ const Char_t * title = "QA makers") ;
AliQADataMakerSteer(const AliQADataMakerSteer & qas) ;
AliQADataMakerSteer & operator = (const AliQADataMakerSteer & qas) ;
virtual ~AliQADataMakerSteer() ;
TString fGAliceFileName ; //! name of the galice file
UInt_t fFirstEvent ; //! first event to process
Int_t fMaxEvents ; //! number of events to process
- char * fMode ; //! sim or rec
+ const Char_t * fMode ; //! sim or rec
Long64_t fNumberOfEvents ; //! number of events in the run
AliRecoParam fRecoParam; //! container for the reco-param objects for detectors
UInt_t fRunNumber ; //! current run number
typedef void (*CompileInfo)( char*& date, char*& time);
CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
if (fctInfo) {
- char* date="";
- char* time="";
- (*fctInfo)(date, time);
- if (!date) date="unknown";
- if (!time) time="unknown";
+ Char_t* date=0;
+ Char_t* time=0;
+ (*fctInfo)(date,time);
+ if (!date) {date=new Char_t[8]; strcpy(date,"unknown");}
+ if (!time) {time=new Char_t[8]; strcpy(time,"unknown");}
AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
+ delete date;
+ delete time;
} else {
AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
}
-void AliSplineFit::MakeSmooth(TGraph * graph, Float_t ratio, char * type){
+void AliSplineFit::MakeSmooth(TGraph * graph, Float_t ratio, Option_t * type){
//
// Interface to GraphSmooth
//
void MakeKnots0(TGraph * graph, Double_t maxdelta, Int_t minpoints);
void SplineFit(Int_t nder);
void CopyGraph();
- void MakeSmooth(TGraph * graph, Float_t ratio, char * type);
+ void MakeSmooth(TGraph * graph, Float_t ratio, Option_t * type);
void Update(TSpline3 *spline, Int_t nknots);
void Cleanup();
Int_t GetKnots() const {return fN;}
-void AliFRAMEv2::MakeHeatScreen(char* name, Float_t dyP, Int_t rot1, Int_t rot2)
+void AliFRAMEv2::MakeHeatScreen(const char* name, Float_t dyP, Int_t rot1, Int_t rot2)
{
// Heat screen panel
//
-void AliFRAMEv2::WebFrame(char* name, Float_t dHz, Float_t theta0, Float_t phi0)
+void AliFRAMEv2::WebFrame(const char* name, Float_t dHz, Float_t theta0, Float_t phi0)
{
//
// Create a web frame element
virtual Int_t IsVersion() const;
virtual void SetHoles(Int_t flag=0) {fHoles = flag;}
virtual Int_t Holes() const {return fHoles;}
- virtual void MakeHeatScreen(char* name, Float_t dyP, Int_t rot1, Int_t rot2);
- virtual void WebFrame(char* name, Float_t dHz, Float_t theta0, Float_t phi0);
+ virtual void MakeHeatScreen(const char* name, Float_t dyP, Int_t rot1, Int_t rot2);
+ virtual void WebFrame(const char* name, Float_t dHz, Float_t theta0, Float_t phi0);
private:
Int_t fHoles; // flag fHoles=0 => no holes, with holes otherwise
}
-TGeoVolume* AliPIPEv3::MakeBellow(char* ext, Int_t nc, Float_t rMin, Float_t rMax, Float_t dU, Float_t rPlie, Float_t dPlie)
+TGeoVolume* AliPIPEv3::MakeBellow(const char* ext, Int_t nc, Float_t rMin, Float_t rMax, Float_t dU, Float_t rPlie, Float_t dPlie)
{
// nc Number of convolution
// rMin Inner radius of the bellow
private:
virtual TGeoPcon* MakeMotherFromTemplate(TGeoPcon* shape, Int_t imin = -1, Int_t imax = -1, Float_t r0 = 0., Int_t nz =-1);
virtual TGeoPcon* MakeInsulationFromTemplate(TGeoPcon* shape);
- virtual TGeoVolume* MakeBellow(char* ext, Int_t nc, Float_t rMin, Float_t rMax, Float_t dU, Float_t rPlie, Float_t dPlie);
+ virtual TGeoVolume* MakeBellow(const char* ext, Int_t nc, Float_t rMin, Float_t rMax, Float_t dU, Float_t rPlie, Float_t dPlie);
protected:
ClassDef(AliPIPEv3,1) //Class for PIPE version using TGeo
};
hwuinc_();
}
-void THerwig6::Hwusta(char* name)
+void THerwig6::Hwusta(const char* name)
{
hwusta_(name,8);
extern "C" {
void hwigin_();
void hwuinc_();
- void hwusta_(char * name, int);
+ void hwusta_(const char * name, int);
void hweini_();
void hwuine_();
void hwepro_();
void SetZJMAX (double d) { fHwhard->ZJMAX = d; }
// /HWPROP/
- Hwprop_t* GetHwprop () { return fHwprop; }
+ Hwprop_t* GetHwprop () const { return fHwprop; }
double GetRMASS (int i) const { return fHwprop->RMASS[i]; }
void SetRMASS (int i, double r) { fHwprop->RMASS[i] = r; }
// /HWUNAM/
- Hwunam_t* GetHwunam () { return fHwunam; }
+ Hwunam_t* GetHwunam () const { return fHwunam; }
void GetRNAME (int i, char a[9]) { for (int j=0;j<8;j++) a[j] = fHwunam->RNAME[i][j]; a[8] = '\0';}
/* char* GetRNAME(int i) { return fHwunam->RNAME[i]; }*/
// /HWUPDT/
- Hwupdt_t* GetHwupdt () { return fHwupdt; }
+ Hwupdt_t* GetHwupdt () const { return fHwupdt; }
// /HWUWTS/
- Hwuwts_t* GetHwuwts () { return fHwuwts; }
+ Hwuwts_t* GetHwuwts () const { return fHwuwts; }
// /HWUCLU/
- Hwuclu_t* GetHwuclu () { return fHwuclu; }
+ Hwuclu_t* GetHwuclu () const { return fHwuclu; }
// /HWDIST/
- Hwdist_t* GetHwdist () { return fHwdist; }
+ Hwdist_t* GetHwdist () const { return fHwdist; }
// /HWQDKT/
- Hwqdks_t* GetHwqdkt () { return fHwqdks; }
+ Hwqdks_t* GetHwqdkt () const { return fHwqdks; }
// /HWUSUD/
- Hwusud_t* GetHwusud () { return fHwusud; }
+ Hwusud_t* GetHwusud () const { return fHwusud; }
// /HWSUSY/
- Hwsusy_t* GetHwsusy () { return fHwsusy; }
+ Hwsusy_t* GetHwsusy () const { return fHwsusy; }
// /HWRPAR/
- Hwrpar_t* GetHwrpar () { return fHwrpar; }
+ Hwrpar_t* GetHwrpar () const { return fHwrpar; }
// /HWMINB/
- Hwminb_t* GetHwminb () { return fHwminb; }
+ Hwminb_t* GetHwminb () const { return fHwminb; }
// /HWCLUS/
- Hwclus_t* GetHwclus () { return fHwclus; }
+ Hwclus_t* GetHwclus () const { return fHwclus; }
// Herwig6 routines
// the user would call
void CloseFortranFile(int lun);
Int_t ImportParticles(TClonesArray *particles, Option_t *option="");
TObjArray *ImportParticles(Option_t *option="");
- TObjArray *Particles() { return fParticles; }
+ TObjArray *Particles() const { return fParticles; }
void Hwigin();
void Hwuinc();
- void Hwusta(char * name);
+ void Hwusta(const char * name);
void Hweini();
void Hwuine();
void Hwepro();
AliInfo(Form("Number of Alignable Volumes: %d",fNTOFAlignObj));
}
//_____________________________________________________________________________
-void AliTOFAlignment::WriteParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFAlignment::WriteParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write Align Par on CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "AlignPar" ;
+ const Char_t *sel1 = "AlignPar" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBId idTOFAlign(out,minrun,maxrun);
man->Put(fTOFAlignObjArray,idTOFAlign,mdTOFAlign);
}
//_____________________________________________________________________________
-void AliTOFAlignment::ReadParFromCDB(Char_t *sel, Int_t nrun)
+void AliTOFAlignment::ReadParFromCDB(const Char_t *sel, Int_t nrun)
{
//Read Align Par from CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "AlignPar" ;
+ const Char_t *sel1 = "AlignPar" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-void AliTOFAlignment::WriteSimParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFAlignment::WriteSimParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write Sim Align Par on CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "AlignSimPar" ;
+ const Char_t *sel1 = "AlignSimPar" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBId idTOFAlign(out,minrun,maxrun);
man->Put(fTOFAlignObjArray,idTOFAlign,mdTOFAlign);
}
//_____________________________________________________________________________
-void AliTOFAlignment::ReadSimParFromCDB(Char_t *sel, Int_t nrun){
+void AliTOFAlignment::ReadSimParFromCDB(const Char_t *sel, Int_t nrun){
//Read Sim Align Par from CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "AlignSimPar" ;
+ const Char_t *sel1 = "AlignSimPar" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
AliTOFAlignment(const AliTOFAlignment &t); //Copy Ctor
AliTOFAlignment& operator=(const AliTOFAlignment &source); // Assignment Operator
virtual ~AliTOFAlignment();
- virtual void WriteParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- virtual void ReadParFromCDB(Char_t *sel, Int_t nrun);
- virtual void WriteSimParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- virtual void ReadSimParFromCDB(Char_t *sel, Int_t nrun);
+ virtual void WriteParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ virtual void ReadParFromCDB(const Char_t *sel, Int_t nrun);
+ virtual void WriteSimParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ virtual void ReadSimParFromCDB(const Char_t *sel, Int_t nrun);
virtual void Smear(Float_t *tr=0, Float_t *rot=0); // create a set of AlignObj for TOF
virtual void Align(Float_t *tr=0, Float_t *rot=0); // create a set of AlignObj for TOF
TObjArray * GetTOFAlignArray() const {return fTOFAlignObjArray;}
fStatus = new AliTOFChannelOnlineStatusArray(fNChannels);
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFcalib::WriteConfigMapOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write calibration parameters to the CDB
SetFirstRun(minrun);
SetLastRun(maxrun);
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliDebug(2,Form("Writing TOF configuration map for online calib on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteConfigMapOnCDB(Char_t *sel)
+void AliTOFcalib::WriteConfigMapOnCDB(const Char_t *sel)
{
//Write calibration parameters to the CDB with infinite validity
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "Config" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBRunRange runrange(fFirstRun,fLastRun);
delete md;
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFcalib::WriteParOnlineDelayOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write calibration parameters to the CDB -------> new calib objs!!!!!
SetFirstRun(minrun);
SetLastRun(maxrun);
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
delete md;
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFcalib::WriteParOnlineStatusOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write calibration parameters to the CDB -------> new calib objs!!!!!
SetFirstRun(minrun);
SetLastRun(maxrun);
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliDebug(2,Form("Writing TOF online status calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineDelayOnCDB(Char_t *sel)
+void AliTOFcalib::WriteParOnlineDelayOnCDB(const Char_t *sel)
{
//Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!!
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "ParOnlineDelay" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBRunRange runrange(fFirstRun,fLastRun);
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineStatusOnCDB(Char_t *sel)
+void AliTOFcalib::WriteParOnlineStatusOnCDB(const Char_t *sel)
{
//Write calibration parameters to the CDB with infinite validity -------> new calib objs!!!!!
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "Status" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBRunRange runrange(fFirstRun,fLastRun);
delete md;
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFcalib::WriteParOnlineOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write calibration parameters to the CDB
SetFirstRun(minrun);
SetLastRun(maxrun);
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliDebug(2,Form("Writing TOF online calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
delete md;
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFcalib::WriteParOnlinePulserOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write calibration parameters from pulser to the CDB
SetFirstRun(minrun);
SetLastRun(maxrun);
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliDebug(2,Form("Writing TOF online calib obj from pulser on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
delete md;
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFcalib::WriteParOnlineNoiseOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write calibration parameters from noise to the CDB
SetFirstRun(minrun);
SetLastRun(maxrun);
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliDebug(2,Form("Writing TOF online calib obj from noise on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
delete md;
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
+void AliTOFcalib::WriteParOnlineHWOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun)
{
//Write calibration parameters from hardware to the CDB
SetFirstRun(minrun);
SetLastRun(maxrun);
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliDebug(2,Form("Writing TOF online calib obj from hardware on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineOnCDB(Char_t *sel)
+void AliTOFcalib::WriteParOnlineOnCDB(const Char_t *sel)
{
//Write calibration parameters to the CDB with infinite validity
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "ParOnline" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBRunRange runrange(fFirstRun,fLastRun);
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlinePulserOnCDB(Char_t *sel)
+void AliTOFcalib::WriteParOnlinePulserOnCDB(const Char_t *sel)
{
//Write calibration parameters from pulser to the CDB with infinite validity
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "Pulser" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBRunRange runrange(fFirstRun,fLastRun);
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineNoiseOnCDB(Char_t *sel)
+void AliTOFcalib::WriteParOnlineNoiseOnCDB(const Char_t *sel)
{
//Write calibration parameters from noise to the CDB with infinite validity
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "Noise" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBRunRange runrange(fFirstRun,fLastRun);
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOnlineHWOnCDB(Char_t *sel)
+void AliTOFcalib::WriteParOnlineHWOnCDB(const Char_t *sel)
{
//Write calibration parameters from hardware to the CDB with infinite validity
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
+ const Char_t *sel1 = "HW" ; // to be consistent with TOFPreprocessor
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBRunRange runrange(fFirstRun,fLastRun);
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun)
+void AliTOFcalib::WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun)
{
//Write calibration parameters to the CDB
SetFirstRun(minrun);
SetLastRun(maxrun);
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOffline" ;
+ const Char_t *sel1 = "ParOffline" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliDebug(2,Form("Writing TOF offline calib obj on CDB with run range [%i, %i] ",fFirstRun,fLastRun));
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity)
+void AliTOFcalib::WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity)
{
//Write calibration parameters to the CDB with infinite validity
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOffline" ;
+ const Char_t *sel1 = "ParOffline" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBRunRange runrange(fFirstRun,fLastRun);
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadConfigMapFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadConfigMapFromCDB(const Char_t *sel, Int_t nrun)
{
//Read calibration parameters from the CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Config" ;
+ const Char_t *sel1 = "Config" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadParOnlineDelayFromCDB(const Char_t *sel, Int_t nrun)
{
//Read calibration parameters from the CDB -------> new calib objs!!!!!
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOnlineDelay" ;
+ const Char_t *sel1 = "ParOnlineDelay" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadParOnlineStatusFromCDB(const Char_t *sel, Int_t nrun)
{
//Read calibration parameters from the CDB -------> new calib objs!!!!!
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Status" ;
+ const Char_t *sel1 = "Status" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadParOnlineFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadParOnlineFromCDB(const Char_t *sel, Int_t nrun)
{
//Read calibration parameters from the CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOnline" ;
+ const Char_t *sel1 = "ParOnline" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadParOnlinePulserFromCDB(const Char_t *sel, Int_t nrun)
{
//Read calibration parameters from pulser from the CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Pulser" ;
+ const Char_t *sel1 = "Pulser" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadParOnlineNoiseFromCDB(const Char_t *sel, Int_t nrun)
{
//Read calibration parameters from noise from the CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "Noise" ;
+ const Char_t *sel1 = "Noise" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadParOnlineHWFromCDB(const Char_t *sel, Int_t nrun)
{
//Read calibration parameters from hardware from the CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "HW" ;
+ const Char_t *sel1 = "HW" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadParOfflineFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadParOfflineFromCDB(const Char_t *sel, Int_t nrun)
{
//Read calibration parameters from the CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "ParOffline" ;
+ const Char_t *sel1 = "ParOffline" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteSimHistoOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo){
+void AliTOFcalib::WriteSimHistoOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo){
//Write Sim miscalibration parameters to the CDB
fTOFSimToT=histo;
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "SimHisto" ;
+ const Char_t *sel1 = "SimHisto" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBMetaData *mdhisto = new AliCDBMetaData();
delete mdhisto;
}
//_____________________________________________________________________________
-Bool_t AliTOFcalib::ReadSimHistoFromCDB(Char_t *sel, Int_t nrun)
+Bool_t AliTOFcalib::ReadSimHistoFromCDB(const Char_t *sel, Int_t nrun)
{
//Read miscalibration parameters from the CDB
AliCDBManager *man = AliCDBManager::Instance();
// The Tot Histo
- Char_t *sel1 = "SimHisto" ;
+ const Char_t *sel1 = "SimHisto" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
return kTRUE;
}
//_____________________________________________________________________________
-void AliTOFcalib::WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){
+void AliTOFcalib::WriteRecParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param){
//Write reconstruction parameters to the CDB
AliCDBManager *man = AliCDBManager::Instance();
AliCDBMetaData *md = new AliCDBMetaData();
md->SetResponsible("Silvia Arcelli");
- Char_t *sel1 = "RecPar" ;
+ const Char_t *sel1 = "RecPar" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBId id(out,minrun,maxrun);
delete md;
}
//_____________________________________________________________________________
-AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(Char_t *sel, Int_t nrun)
+AliTOFRecoParam * AliTOFcalib::ReadRecParFromCDB(const Char_t *sel, Int_t nrun)
{
//Read reconstruction parameters from the CDB
AliCDBManager *man = AliCDBManager::Instance();
- Char_t *sel1 = "RecPar" ;
+ const Char_t *sel1 = "RecPar" ;
Char_t out[100];
sprintf(out,"%s/%s",sel,sel1);
AliCDBEntry *entry = man->Get(out,nrun);
// Methods to retrieve/write parameters from/on CDB
// writing
- void WriteSimHistoOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo);
- void WriteConfigMapOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- void WriteConfigMapOnCDB(Char_t *sel);
+ void WriteSimHistoOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, TH1F *histo);
+ void WriteConfigMapOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ void WriteConfigMapOnCDB(const Char_t *sel);
// new calib objs
- void WriteParOnlineDelayOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- void WriteParOnlineStatusOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- void WriteParOnlineDelayOnCDB(Char_t *sel);
- void WriteParOnlineStatusOnCDB(Char_t *sel);
+ void WriteParOnlineDelayOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ void WriteParOnlineStatusOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ void WriteParOnlineDelayOnCDB(const Char_t *sel);
+ void WriteParOnlineStatusOnCDB(const Char_t *sel);
// old calib objs
- void WriteParOnlineOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- void WriteParOnlinePulserOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- void WriteParOnlineNoiseOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- void WriteParOnlineHWOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun);
- void WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun);
- void WriteParOnlineOnCDB(Char_t *sel);
- void WriteParOnlinePulserOnCDB(Char_t *sel); // old, before unification of status info
- void WriteParOnlineNoiseOnCDB(Char_t *sel); // old, before unification of status info
- void WriteParOnlineHWOnCDB(Char_t *sel); // old, before unification of status info
- void WriteParOfflineOnCDB(Char_t *sel, const Char_t *validity);
+ void WriteParOnlineOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ void WriteParOnlinePulserOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ void WriteParOnlineNoiseOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ void WriteParOnlineHWOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun);
+ void WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity, Int_t minrun, Int_t maxrun);
+ void WriteParOnlineOnCDB(const Char_t *sel);
+ void WriteParOnlinePulserOnCDB(const Char_t *sel); // old, before unification of status info
+ void WriteParOnlineNoiseOnCDB(const Char_t *sel); // old, before unification of status info
+ void WriteParOnlineHWOnCDB(const Char_t *sel); // old, before unification of status info
+ void WriteParOfflineOnCDB(const Char_t *sel, const Char_t *validity);
// reading
- Bool_t ReadSimHistoFromCDB(Char_t *sel, Int_t nrun);
- Bool_t ReadConfigMapFromCDB(Char_t *sel, Int_t nrun);
+ Bool_t ReadSimHistoFromCDB(const Char_t *sel, Int_t nrun);
+ Bool_t ReadConfigMapFromCDB(const Char_t *sel, Int_t nrun);
// new objs
- Bool_t ReadParOnlineDelayFromCDB(Char_t *sel, Int_t nrun);
- Bool_t ReadParOnlineStatusFromCDB(Char_t *sel, Int_t nrun);
+ Bool_t ReadParOnlineDelayFromCDB(const Char_t *sel, Int_t nrun);
+ Bool_t ReadParOnlineStatusFromCDB(const Char_t *sel, Int_t nrun);
// old objs
- Bool_t ReadParOnlineFromCDB(Char_t *sel, Int_t nrun);
- Bool_t ReadParOnlinePulserFromCDB(Char_t *sel, Int_t nrun); // old, before unification of status info
- Bool_t ReadParOnlineNoiseFromCDB(Char_t *sel, Int_t nrun); // old, before unification of status info
- Bool_t ReadParOnlineHWFromCDB(Char_t *sel, Int_t nrun); // old, before unification of status info
- Bool_t ReadParOfflineFromCDB(Char_t *sel, Int_t nrun);
- void WriteRecParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param);
- AliTOFRecoParam * ReadRecParFromCDB(Char_t *sel, Int_t nrun);
+ Bool_t ReadParOnlineFromCDB(const Char_t *sel, Int_t nrun);
+ Bool_t ReadParOnlinePulserFromCDB(const Char_t *sel, Int_t nrun); // old, before unification of status info
+ Bool_t ReadParOnlineNoiseFromCDB(const Char_t *sel, Int_t nrun); // old, before unification of status info
+ Bool_t ReadParOnlineHWFromCDB(const Char_t *sel, Int_t nrun); // old, before unification of status info
+ Bool_t ReadParOfflineFromCDB(const Char_t *sel, Int_t nrun);
+ void WriteRecParOnCDB(const Char_t *sel, Int_t minrun, Int_t maxrun, AliTOFRecoParam *param);
+ AliTOFRecoParam * ReadRecParFromCDB(const Char_t *sel, Int_t nrun);
void CreateTreeFromCDB(Int_t minrun, Int_t maxrun);
void CreateTreeFromFile(Int_t minrun, Int_t maxrun);
void CreateTreeFromGrid(Int_t minrun, Int_t maxrun);
return 0;
}
-int AliTPCAltroEmulator::InRange(int parameter,int Low,int High,char *Module,char *ParameterName){
+int AliTPCAltroEmulator::InRange(int parameter,int Low,int High,const char *Module,const char *ParameterName){
//
//
//
void SetElement(short* Array,int index,short value);
int InBand(int ADC,int bsl, int LowThreshold, int HighThreshold);
- int InRange(int parameter,int Low,int High,char *Module,char *ParameterName);
+ int InRange(int parameter,int Low,int High,const char *Module,const char *ParameterName);
short GetShortChannel(int i);
short GetKeepChannel(int i);
int Multiply36(int P, int N);
//_____________________________________________________________________
TH2S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
- Char_t *type, Bool_t force)
+ const Char_t *type, Bool_t force)
{
//
// return pointer to TH2S histogram of 'type'
}
//_____________________________________________________________________
TH1S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
- Char_t *type, Bool_t force)
+ const Char_t *type, Bool_t force)
{
//
// return pointer to TH1S histogram
TH2S* GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
- Char_t *type, Bool_t force);
+ const Char_t *type, Bool_t force);
TH1S* GetHisto(Int_t sector, TObjArray *arr,
- Char_t *type, Bool_t force);
+ const Char_t *type, Bool_t force);
AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const;
//_____________________________________________________________________
TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
- Char_t *type, Bool_t force)
+ const Char_t *type, Bool_t force)
{
//
// return pointer to Q histogram
TH2F* GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
- Char_t *type, Bool_t force);
+ const Char_t *type, Bool_t force);
AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force);
//_____________________________________________________________________
TH2S* AliTPCCalibPulser::GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
- Char_t *type, Bool_t force)
+ const Char_t *type, Bool_t force)
{
//
// return pointer to Q histogram
TH2S* GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
- Char_t *type, Bool_t force);
+ const Char_t *type, Bool_t force);
AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const;
}
//_____________________________________________________________________________
-AliTPCCalibViewer::AliTPCCalibViewer(char* fileName, char* treeName)
+AliTPCCalibViewer::AliTPCCalibViewer(const char* fileName, const char* treeName)
:TObject(),
fTree(0),
fFile(0),
//_____________________________________________________________________________
-AliTPCCalPad* AliTPCCalibViewer::GetCalPadOld(const char* desiredData, char* cuts, char* calPadName) const {
+AliTPCCalPad* AliTPCCalibViewer::GetCalPadOld(const char* desiredData, const char* cuts, const char* calPadName) const {
//
// creates a AliTPCCalPad out of the 'desiredData'
// the functionality of EasyDraw1D is used
//_____________________________________________________________________________
-AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, char* cuts, char* calPadName) const {
+AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, const char* cuts, const char* calPadName) const {
//
// creates a AliTPCCalPad out of the 'desiredData'
// the functionality of EasyDraw1D is used
AliTPCCalibViewer();
AliTPCCalibViewer(const AliTPCCalibViewer &c);
AliTPCCalibViewer(TTree* tree);
- AliTPCCalibViewer(char* fileName, char* treeName = "calPads");
+ AliTPCCalibViewer(const char* fileName, const char* treeName = "calPads");
AliTPCCalibViewer &operator = (const AliTPCCalibViewer & param);
virtual ~AliTPCCalibViewer();
virtual void Delete(Option_t* option = "");
Int_t Integrate(const char* drawCommand, Int_t sector, const char* cuts = 0, Float_t sigmaMax = 5, Bool_t plotMean = kTRUE, Bool_t plotMedian = kTRUE, Bool_t plotLTM = kTRUE, const char *sigmas = "", Float_t sigmaStep = -1) const; // draws an integrated histogram
Int_t IntegrateOld(const char* drawCommand, const char* sector, const char* cuts = 0, Float_t sigmaMax = 5, Bool_t plotMean = kTRUE, Bool_t plotMedian = kTRUE, Bool_t plotLTM = kTRUE, const char *sigmas = "", Float_t sigmaStep = -1) const; // draws an integrated histogram
- AliTPCCalPad* GetCalPadOld(const char* desiredData, char* cuts = "", char* calPadName = "NoName") const; // returns an AliTPCCalPad object containing the specified data with cuts applied
- AliTPCCalPad* GetCalPad(const char* desiredData, char* cuts = "", char* calPadName = "NoName") const; // returns an AliTPCCalPad object containing the specified data with cuts applied
+ AliTPCCalPad* GetCalPadOld(const char* desiredData, const char* cuts = "", const char* calPadName = "NoName") const; // returns an AliTPCCalPad object containing the specified data with cuts applied
+ AliTPCCalPad* GetCalPad(const char* desiredData, const char* cuts = "", const char* calPadName = "NoName") const; // returns an AliTPCCalPad object containing the specified data with cuts applied
AliTPCCalROC* GetCalROC(const char* desiredData, UInt_t sector, char* cuts = "") const; // returns an AliTPCCalROC object containing the specified data for sector with cuts applied
*/
-void AliTPCCalibViewerGUI::Initialize(char* fileName, char* treeName) {
+void AliTPCCalibViewerGUI::Initialize(const char* fileName, const char* treeName) {
//
// initialize the GUI with a calibrationTree from fileName
//
void DrawGUI(const TGWindow *p, UInt_t w, UInt_t h); // to be called by the costructor, here the windows is drawn
void SetInitialValues(); // set the initial button states
- void Initialize(char* fileName, char* treeName = "calPads"); // initializes the GUI with default settings and opens tree for drawing
+ void Initialize(const char* fileName, const char* treeName = "calPads"); // initializes the GUI with default settings and opens tree for drawing
void Initialize(AliTPCCalibViewer *viewer); // initializes the GUI with default settings and opens tree for drawing
void Reload(){Initialize(fViewer);} // reload the viewr after it has been changed, e.g. added a new referenceTree, ...
TString* GetDrawString(); // create the draw string out of selection
//if we cross two boarders on our way return the closer boarder
- if ( (n1>0) && (n2>0) )
+ if ( (n1>0) && (n2>0) ) {
if ( (vF-vI1).Mag() <= (vF-vI2).Mag() )
return (vF-vI1).Mag();
else
- return (vF-vI2).Mag();
+ return (vF-vI2).Mag();
+ }
if ( n1>0 )
return (vF-vI1).Mag();
}
//__________________________________________________________________
-TCanvas* AliTPCMonitor::CreateCanvas(Char_t* name)
+TCanvas* AliTPCMonitor::CreateCanvas(const Char_t* name)
{
// Create Canvases
virtual ~AliTPCMonitor();
Int_t CheckEqId(Int_t secid, Int_t eqid);
- TCanvas* CreateCanvas(char* name);
+ TCanvas* CreateCanvas(const char* name);
void CreateHistos();
void DeleteHistos();
for(Int_t iTimeBin=1;iTimeBin<kNTime-1;iTimeBin++){\r
if (!ifMaximum) {\r
if (val[iTimeBin]==-1) break; // 0 until the end\r
- for( ; iTimeBin<kNTime-2&&val[iTimeBin]<fMinAdc ;iTimeBin++);\r
+ for( ; iTimeBin<kNTime-2&&val[iTimeBin]<fMinAdc ;iTimeBin++) {}\r
}\r
//\r
Short_t adc = val[iTimeBin];\r
//_____________________________________________________________________
TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, TObjArray *arr, /*FOLD00*/
Int_t nbinsY, Float_t ymin, Float_t ymax,
- Char_t *type, Bool_t force)
+ const Char_t *type, Bool_t force)
{
//
// return pointer to histogram
TH2F* GetHisto(Int_t det, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
- Char_t *type, Bool_t force);
+ const Char_t *type, Bool_t force);
// Some basic geometry function
virtual Int_t GetLayer(Int_t d) const;
TClonesArray *ar = new TClonesArray("AliAlignObjParams",10000);
NumbersToAr(ar);
- char *path = "TRD/Align/Data";
+ const Char_t *path = "TRD/Align/Data";
AliCDBId id(path,run0,run1);
AliCDBMetaData *md = new AliCDBMetaData();
md->SetResponsible("Dariusz Miskowiec");
//---------------------------------------------------------------------
-Char_t * AliTRDrawTPStream::Addr2Name(UInt_t addr)
+const Char_t * AliTRDrawTPStream::Addr2Name(UInt_t addr)
{
Int_t idx;
idx = 0;
public:
struct SimpleRegs {
- Char_t * fName; //! Name of the register
+ const Char_t * fName; //! Name of the register
UInt_t fAddr; // Address in GIO of TRAP
UInt_t fNbits; // Number of bits, from 1 to 32
UInt_t fResVal; // reset value [mj]
};
struct CmdRegs{
- Char_t * fName; //! Name of the command register
+ const Char_t * fName; //! Name of the command register
UInt_t fAddr; // Address in GIO of TRAP
};
Int_t AddrIsDmem(UInt_t addr);
Int_t AddrIsDbank(UInt_t addr);
UInt_t Addr2Idx(UInt_t addr);
- Char_t * Addr2Name(UInt_t addr); //!
+ const Char_t * Addr2Name(UInt_t addr); //!
Char_t CnfStat(UInt_t prop);
void PowerUp();
void DumpCnf(Int_t slv);
ClassImp(AliTRDCalPID)
-Char_t* AliTRDCalPID::fPartName[AliPID::kSPECIES] = { "electron", "muon", "pion", "kaon", "proton"};
-Char_t* AliTRDCalPID::fPartSymb[AliPID::kSPECIES] = { "EL", "MU", "PI", "KA", "PR"};
+const Char_t* AliTRDCalPID::fPartName[AliPID::kSPECIES] = { "electron", "muon", "pion", "kaon", "proton"};
+const Char_t* AliTRDCalPID::fPartSymb[AliPID::kSPECIES] = { "EL", "MU", "PI", "KA", "PR"};
Color_t AliTRDCalPID::fPartColor[AliPID::kSPECIES] = { kRed, kGreen, kBlue, kYellow, kMagenta};
Float_t AliTRDCalPID::fTrackMomentum[kNMom] = {
0.6, 0.8, 1.0, 1.5, 2.0
, Float_t length, Int_t plane) const = 0;
static Color_t GetPartColor(Int_t i) { return fPartColor[i]; }
static Int_t GetPartIndex(Int_t pdg);
- static Char_t *GetPartName(Int_t i) { return fPartName[i]; }
- static Char_t *GetPartSymb(Int_t i) { return fPartSymb[i]; }
+ static const Char_t *GetPartName(Int_t i) { return fPartName[i]; }
+ static const Char_t *GetPartSymb(Int_t i) { return fPartSymb[i]; }
- void SetPartName(Int_t i, Char_t *name) { fPartName[i] = name; }
- void SetPartSymb(Int_t i, Char_t *symb) { fPartSymb[i] = symb; }
+ void SetPartName(Int_t i, const Char_t *name) { fPartName[i] = name; }
+ void SetPartSymb(Int_t i, const Char_t *symb) { fPartSymb[i] = symb; }
protected:
protected:
- static Char_t *fPartName[AliPID::kSPECIES]; //! Names of particle species
- static Char_t *fPartSymb[AliPID::kSPECIES]; //! Symbols of particle species
+ static const Char_t *fPartName[AliPID::kSPECIES]; //! Names of particle species
+ static const Char_t *fPartSymb[AliPID::kSPECIES]; //! Symbols of particle species
static Color_t fPartColor[AliPID::kSPECIES]; //! Colors of particle species
static Float_t fTrackMomentum[kNMom]; // Track momenta for which response functions are available
TObjArray *fModel; // Model for probability estimate
,kPIDRefMaker = 7
};
-Char_t* fgkTRDtaskClassName[NTRDTASKS] = {
+const Char_t* fgkTRDtaskClassName[NTRDTASKS] = {
"AliTRDcheckDetector"
,"AliTRDtrackingEfficiency"
,"AliTRDtrackingEfficiencyCombined"
,"AliTRDpidRefMaker"
};
-Char_t *fgkTRDtaskOpt[NTRDTASKS+3] = {
+const Char_t *fgkTRDtaskOpt[NTRDTASKS+3] = {
"ALL"
,"DET"
,"EFF"
//=============================================================================
#include <cmath>
+#include <stdlib.h>
+
#include <TFile.h>
#include <TDirectory.h>
#include <TAxis.h>
BCM/module.mk: BCM/libBCM.pkg
DPMJET/module.mk: DPMJET/libdpmjet.pkg
TDPMjet/module.mk: TDPMjet/libTDPMjet.pkg
-ISAJET/module.mk: ISAJET/libisajet.pkg
-TIsajet/module.mk: TIsajet/libTIsajet.pkg
TTherminator/module.mk: TTherminator/libTTherminator.pkg
CORRFW/module.mk: CORRFW/libCORRFW.pkg
UNICOR/module.mk: UNICOR/libUNICOR.pkg