}
//________________________________________________________________
-AliACORDECalibData::AliACORDECalibData(const char* name)
+AliACORDECalibData::AliACORDECalibData(const char* name) :
+ TNamed(),
+ fHits(0),
+ fTHits(0),
+ fMultiHits(0),
+ fTMultiHits(0)
{
TString namst = "Calib_";
namst += name;
//________________________________________________________________
AliACORDECalibData::AliACORDECalibData(const AliACORDECalibData& calibda) :
- TNamed(calibda)
+ TNamed(calibda),
+ fHits(0),
+ fTHits(0),
+ fMultiHits(0),
+ fTMultiHits(0)
{
// copy constructor
}
}
//_______________________________________________________________
-void AliACORDECalibData::Draw()
+void AliACORDECalibData::Draw(Option_t *)
{
void AddHTHits(TH1D *Histo){fTHits=(TH1D*)Histo->Clone("Total Hits");}//Total Hits
void AddHMultiHits(TH1D *Histo){fMultiHits=(TH1D*)Histo->Clone("MultiHits");}//
void AddHTMultiHits(TH1D *Histo){fTMultiHits=(TH1D*)Histo->Clone("Total Multi Hits");}
- void Draw();
+ void Draw(Option_t *option="");
protected:
//fGraphLinear3->SetPointError(i, TMath::Abs(x[i])*0.001, TMath::Abs(yCoor)*0.05, TMath::Abs(zCoor)*0.05);
}
- TCanvas * canvas;
+ TCanvas * canvas=0;
if (gPad) gPad->Clear();
else if (gPad==0 || gPad->GetCanvas()->IsEditable() == kFALSE) {
canvas = new TCanvas("canvas", "CosmicRayFitter", 800, 800);
public:
struct SourceId
{
+ SourceId(): fDet(), fSDet(), fSSDet(), fType() {}
TString fDet, fSDet, fSSDet, fType;
struct CmpByDet
/******************************************************************************/
AliEveHOMERSourceMapByDet::AliEveHOMERSourceMapByDet(ESourceGrouping_e grouping) :
- AliEveHOMERSourceMap(grouping)
+ AliEveHOMERSourceMap(grouping),
+ fMap()
{}
TString AliEveHOMERSourceMapByDet::iterator_imp::description()
/******************************************************************************/
AliEveHOMERSourceMapByType::AliEveHOMERSourceMapByType(ESourceGrouping_e grouping) :
- AliEveHOMERSourceMap(grouping)
+ AliEveHOMERSourceMap(grouping),
+ fMap()
{}
TString AliEveHOMERSourceMapByType::iterator_imp::description()
iterator_imp_base* m_imp;
iterator() : m_imp(0) {}
+ iterator(const iterator& it) : m_imp(it.m_imp->clone()) {}
iterator(iterator_imp_base* imp) : m_imp(imp) {}
~iterator() { delete m_imp; }
}
//_____________________________________________________________________
-AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& qadm)
+AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& /*qadm*/)
: AliQADataMakerRec()
{
// copy ctor
}
//_____________________________________________________________________
-void AliFMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
+void AliFMDQADataMakerRec::MakeRaws(AliRawReader* /*rawReader*/)
{
}
}
//_____________________________________________________________________
-AliFMDQADataMakerSim::AliFMDQADataMakerSim(const AliFMDQADataMakerSim& qadm)
+AliFMDQADataMakerSim::AliFMDQADataMakerSim(const AliFMDQADataMakerSim& /*qadm*/)
: AliQADataMakerSim()
{
//copy ctor
# else
TBuffer(kWrite),
# endif
- AliHLTLogging()
+ AliHLTLogging(),
+ fWhat(what),
+ fClass(0),
+ fCompress(0),
+ fBufComp(0),
+ fBufCompCur(0),
+ fCompPos(0)
{
// Create a AliHLTMessage object for storing objects. The "what" integer
// describes the type of message. Predifined ROOT system message types
UInt_t reserved = 0;
*this << reserved;
- fWhat = what;
*this << what;
- fClass = 0;
- fCompress = 0;
- fBufComp = 0;
- fBufCompCur = 0;
- fCompPos = 0;
}
//______________________________________________________________________________
# else
TBuffer(kRead, bufsize, buf, 0),
# endif
- AliHLTLogging()
+ AliHLTLogging(),
+ fWhat(0),
+ fClass(0),
+ fCompress(0),
+ fBufComp(0),
+ fBufCompCur(0),
+ fCompPos(0)
{
// Create a AliHLTMessage object for reading objects. The objects will be
// read from buf. Use the What() method to get the message type.
*this >> fWhat;
- fCompress = 0;
- fBufComp = 0;
- fBufCompCur = 0;
- fCompPos = 0;
-
if (fWhat & kMESS_ZIP) {
// if buffer has kMESS_ZIP set, move it to fBufComp and uncompress
fBufComp = fBuffer;
#include "TMath.h"
//#include "Riostream.h"
#include <vector>
-#include <algo.h>
+#include <algorithm>
#include "TStopwatch.h"
//#define DRAW
AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent(const AliHLTTPCCATrackerComponent&)
:
+ AliHLTProcessor(),
fTracker(NULL),
fBField(0)
{
(
const AliHLTComponentEventData& evtData,
const AliHLTComponentBlockData* blocks,
- AliHLTComponentTriggerData& trigData,
+ AliHLTComponentTriggerData& /*trigData*/,
AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t& size,
vector<AliHLTComponentBlockData>& outputBlocks )
if( !fTracker ) fTracker = new AliHLTTPCCATracker;
Int_t iSec = slice;
Double_t inRmin = 83.65;
- Double_t inRmax = 133.3;
- Double_t outRmin = 133.5;
+ // Double_t inRmax = 133.3;
+ // Double_t outRmin = 133.5;
Double_t outRmax = 247.7;
Double_t plusZmin = 0.0529937;
Double_t plusZmax = 249.778;
Double_t zMin = zPlus ?plusZmin :minusZmin;
Double_t zMax = zPlus ?plusZmax :minusZmax;
//TPCZmin = -249.645, ZMax = 249.778
- Double_t rMin = inRmin;
- Double_t rMax = outRmax;
+ // Double_t rMin = inRmin;
+ // Double_t rMax = outRmax;
Int_t NRows = AliHLTTPCTransform::GetNRows();
Double_t padPitch = 0.4;
enum EClusterStatus {kFrm,kCoG,kLo1,kUnf,kMax,kNot,kEdg,kSi1,kNoLoc,kAbn,kEmp=-1}; //status flags
AliHMPIDCluster():AliCluster3D(),
fCh(-1),fSi(-1),fSt(kEmp),fBox(-1),fNlocMax(-1),fMaxQpad(-1),fMaxQ(-1),fQRaw(0),
- fQ(0),fErrQ(-1),fXX(0),fErrX(-1),fYY(0),fErrY(-1),fChi2(-1),fDigs(0)
+ fQ(0),fErrQ(-1),fXX(0),fErrX(-1),fYY(0),fErrY(-1),fChi2(-1),fDigs(0),fParam(AliHMPIDParam::Instance())
{
- AliHMPIDParam *pParam=AliHMPIDParam::Instance();
- fParam = pParam;
}//ctor
fCh(c.fCh),fSi(c.fSi),fSt(c.fSt),fBox(c.fBox),fNlocMax(c.fNlocMax),fMaxQpad(c.fMaxQpad),fMaxQ(c.fMaxQ),fQRaw(c.fQRaw),
fQ (c.fQ ),fErrQ(c.fErrQ),
fXX (c.fXX ),fErrX(c.fErrX),
- fYY (c.fYY ),fErrY(c.fErrY),fChi2(c.fChi2),fDigs(0) {}//copy ctor
+ fYY (c.fYY ),fErrY(c.fErrY),fChi2(c.fChi2),fDigs(0),fParam(c.fParam) {}//copy ctor
virtual ~AliHMPIDCluster();//dtor {if(fDigs) delete fDigs; fDigs=0;}
//framework part
void Draw (Option_t *opt="" ); //overloaded TObject::Print() to draw cluster in current canvas
Int_t AliHMPIDParam::fgSigmas=4;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDParam::AliHMPIDParam(Bool_t noGeo=kFALSE):TNamed("HmpidParam","default version")
+AliHMPIDParam::AliHMPIDParam(Bool_t noGeo=kFALSE):
+ TNamed("HmpidParam","default version"),
+ fX(0), fY(0), fRadNmean(0)
{
// Here all the intitializition is taken place when AliHMPIDParam::Instance() is invoked for the first time.
// In particular, matrices to be used for LORS<->MARS trasnformations are initialized from TGeo structure.
*/
fPosition = 0;
- Bool_t status;
+ Bool_t status=kTRUE;
Int_t rawDataSize=0;
if(fRawReader->GetType() == 7 || fRawReader->GetType() == 8 ) { //New: Select Physics events, Old: Raw data size is not 0 and not 47148 (pedestal)
fDDLNumber = fRawReader->GetDDLID();
#include <AliESDtrack.h> //CkovAngle()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDRecon::AliHMPIDRecon():TTask("RichRec","RichPat")
+AliHMPIDRecon::AliHMPIDRecon():
+ TTask("RichRec","RichPat"),
+ fPhotCnt(-1),
+ fPhotFlag(0),
+ fPhotCkov(0),
+ fPhotPhi(0),
+ fPhotWei(0),
+ fCkovSigma2(0),
+ fIsWEIGHT(kFALSE),
+ fDTheta(0.001),
+ fWindowWidth(0.045),
+ fRingArea(0),
+ fRingAcc(0),
+ fTrkDir(0,0,1), // Just for test
+ fTrkPos(30,40), // Just for test
+ fMipPos(0),
+ fPc(0),
+ fParam(AliHMPIDParam::Instance())
{
//..
//init of data members
//..
- fPhotCnt = -1;
- fPhotFlag = 0x0;
- fPhotCkov = 0x0;
- fPhotPhi = 0x0;
- fPhotWei = 0x0;
- fCkovSigma2 = 0;
- fIsWEIGHT = kFALSE;
- fDTheta = 0.001;
- fWindowWidth = 0.045;
- fTrkDir = TVector3(0,0,1); // init just for test
- fTrkPos = TVector2(30,40); // init just for test
-
- AliHMPIDParam *pParam=AliHMPIDParam::Instance();
- fParam = pParam;
-
fParam->SetRefIdx(fParam->MeanIdxRad()); // initialization of ref index to a default one
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TH2I* AliHMPIDReconHTA::fgDatabase = 0x0;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDReconHTA::AliHMPIDReconHTA():TTask("RichRec","RichPat")
+AliHMPIDReconHTA::AliHMPIDReconHTA():
+ TTask("RichRec","RichPat"),
+ fMipX(-999),
+ fMipY(-999),
+ fMipQ(-999),
+ fRadX(-999),
+ fRadY(-999),
+ fIdxMip(0),
+ fNClu(0),
+ fXClu(0),
+ fYClu(0),
+ fClCk(0),
+ fThTrkFit(-999),
+ fPhTrkFit(-999),
+ fCkovFit(-999),
+ fCkovSig2(0),
+ fParam(AliHMPIDParam::Instance())
{
//..
//hidden algorithm
//..
- fMipX=fMipY=fThTrkFit=fPhTrkFit=fCkovFit=fMipQ=fRadX=fRadY=-999;
- fIdxMip=fNClu=0;
- fCkovSig2=0;
- fXClu = 0x0;
- fYClu = 0x0;
- fClCk = 0x0;
-
- fParam=AliHMPIDParam::Instance();
-
fParam->SetRefIdx(fParam->MeanIdxRad()); // initialization of ref index to a default one
if(!fgDatabase) InitDatabase();
}
AliInfo(Form("database HTA is being built.Please, wait..."));
//
- Double_t x[3],y[3];
+ Double_t x[3]={0,0,0},y[3];
AliHMPIDRecon rec;
//.
ClassImp(AliHMPIDTracker)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDTracker::AliHMPIDTracker():AliTracker()
+AliHMPIDTracker::AliHMPIDTracker():
+ AliTracker(),
+ fClu(new TObjArray(AliHMPIDParam::kMaxCh+1))
{
// ctor. Create TObjArray of TClonesArray of AliHMPIDCluster
//
//
- fClu=new TObjArray(AliHMPIDParam::kMaxCh+1); fClu->SetOwner(kTRUE);
+ fClu->SetOwner(kTRUE);
for(int i=AliHMPIDParam::kMinCh;i<=AliHMPIDParam::kMaxCh;i++) fClu->AddAt(new TClonesArray("AliHMPIDCluster"),i);
}//ctor
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
dNdEtaAnalysis::dNdEtaAnalysis(const dNdEtaAnalysis &c) :
TNamed(c),
fData(0),
+ fMult(0),
fPtDist(0)
{
//
fRapMin(0),
fRapMax(0),
fHistogramsOn(0),
+ ffDTheoretical(0),
fhCutStatistics(0),
fhCutCorrelation(0)
{
Int_t nV0s = fESD->GetNumberOfV0s();
Int_t nCascades = fESD->GetNumberOfCascades();
Int_t nKinks = fESD->GetNumberOfKinks();
- Int_t nVertices = nV0s + nCascades + nKinks + 1 /* = prim. vtx*/;
- Int_t nJets = 0;
- Int_t nCaloClus = fESD->GetNumberOfCaloClusters();
- Int_t nFmdClus = 0;
- Int_t nPmdClus = fESD->GetNumberOfPmdTracks();
+ // Int_t nVertices = nV0s + nCascades + nKinks + 1 /* = prim. vtx*/;
+ // Int_t nJets = 0;
+ // Int_t nCaloClus = fESD->GetNumberOfCaloClusters();
+ // Int_t nFmdClus = 0;
+ // Int_t nPmdClus = fESD->GetNumberOfPmdTracks();
printf(" NV0=%d NCASCADES=%d NKINKS=%d\n", nV0s, nCascades, nKinks);
fRapMin(0),
fRapMax(0),
fHistogramsOn(0),
+ ffDTheoretical(0),
fhCutStatistics(0),
fhCutCorrelation(0)
{
#include "AliT0RawReader.h"
#include "TGLabel.h"
#include "TGFileDialog.h"
-#include <iostream.h>
+#include <iostream>
#include "AliT0CalibLaserData.h"
#include <TF1.h>
#include <TSpectrum.h>
#include <TProfile.h>
-#include "iostream.h"
+#include <iostream>
ClassImp(AliT0CalibTimeEq)
virtual void InitHits() ; //book hit QA histo
virtual void InitDigits() ; //book Digit QA histo
virtual void MakeHits(TTree * hits) ; //Fill hit QA histo
+ virtual void MakeHits(TClonesArray *) {} //Dummy for the moment
virtual void MakeDigits(TTree* digitsTree) ; //Fill Digit QA histo
+ virtual void MakeDigits(TClonesArray *) {} //Dummy for the moment
virtual void EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
virtual void StartOfDetectorCycle() ;
ClassDef(AliT0QADataMakerSim,1) // description
fPartDB = new ParticleDB();
}
TTherminator::TTherminator(const TTherminator & therm) :
+ TGenerator(therm),
fCalka(0),
fEvent(0),
fPartDB(0)
}
}
-Int_t TTherminator::ImportParticles(TClonesArray *particles, Option_t *option)
+Int_t TTherminator::ImportParticles(TClonesArray *particles, Option_t */*option*/)
{
// Import particles from a generated event into an external array
if (particles == 0) return 0;
return nump;
}
-TObjArray* TTherminator::ImportParticles(Option_t *option)
+TObjArray* TTherminator::ImportParticles(Option_t */*option*/)
{
// Import generated particles into an internal array
Int_t nump = 0;
tFMax = aPartType->GetFMax();
(*oParticles) = (Particle **) malloc(sizeof(Particle *) * aPartCount);
- Particle *tBuf;
+ Particle *tBuf=0;
while (tIter<aPartCount)
{
void Parser::ReadInput()
{
- int j,tPartIter,l,tIter2, tIter; //variables
+ int j,tPartIter=0,l,tIter2, tIter; //variables
char str[50];
char str1[20];
double spin1,spin2,value;
delete mTable;
}
-void ParticleType::WriteParticle(int i)
+void ParticleType::WriteParticle(int /*i*/)
{
mMass=-1;
mStrangeness=-1;
buffer->WriteMBFlags();
buffer->WriteBeamScalers();
}
- for(Int_t kChannel = kChannel=0; kChannel < 8; kChannel++) {
- buffer->WriteTiming(kChannel, ADC[kChannel], Time[kChannel]);
+ for(Int_t iChannel=0; iChannel < 8; iChannel++) {
+ buffer->WriteTiming(iChannel, ADC[iChannel], Time[iChannel]);
}
// End of decoding of one CIU card
timer.Stop();
timer.Print();
+ return kTRUE;
}
}
//_____________________________________________________________________________
-void AliVZEROBuffer::WriteChannel(Int_t cell, UInt_t ADC, UInt_t Time){
+void AliVZEROBuffer::WriteChannel(Int_t cell, UInt_t ADC, UInt_t /*Time*/){
// It writes VZERO charge information into a raw data file.
// Being called by Digits2Raw
UInt_t data = 0;
- if (ADC < 0 || ADC > 1023) {
+ if (/*ADC < 0 || */ ADC > 1023) {
AliInfo(Form("ADC saturated: %d. Truncating to 1023",ADC));
ADC = 1023;
}
}
//_____________________________________________________________________________
-void AliVZEROBuffer::WriteTiming(Int_t cell, UInt_t ADC, UInt_t Time){
+void AliVZEROBuffer::WriteTiming(Int_t /*cell*/, UInt_t /* ADC*/, UInt_t Time){
// It writes the timing information into a raw data file.
// Being called by Digits2Raw
// method to introduce new aliases
- int entries=entries = aliasArr->GetEntries();
+ int entries=aliasArr->GetEntries();
AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
AliInfo(Form(" %d DP values collected",entries));
Float_t* GetWidthHV() const {return (float*)fWidthHV;}
private:
+ AliVZERODataDCS(const AliVZERODataDCS&); // Not implemented
+ AliVZERODataDCS& operator=(const AliVZERODataDCS&); // Not implemented
+
void Init();
void Introduce(UInt_t numAlias, const TObjArray* aliasArr) const;
void CreateGraph(int i, int dim, const Double_t *x, const Double_t *y);
// Initialises the Digit array
fDigits = new TClonesArray ("AliVZEROdigit", 1000);
- TGeoHMatrix *im = AliGeomManager::GetMatrix("VZERO/V0C");
-// im->Print();
+ // TGeoHMatrix *im = AliGeomManager::GetMatrix("VZERO/V0C");
+ // im->Print();
return kTRUE;
}
// Also adds the ADC pedestals taken out of the calibration data base
for (Int_t j=0; j<16; j++){
- adc[j] = map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]);
+ adc[j] = static_cast<Int_t>(map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]));
time2[j]= time[j];}
for (Int_t j=48; j<80; j++){
- adc[j-16] = map [j]
- + gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]);
+ adc[j-16] = static_cast<Int_t>(map [j]
+ + gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]));
time2[j-16]= time[j]; }
for (Int_t j=0; j<16; j++){
- adc[16+j] = map [16+2*j]+ map [16+2*j+1]
- + gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]);
+ adc[16+j] = static_cast<Int_t>(map [16+2*j]+ map [16+2*j+1]
+ + gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]));
Float_t min_time = TMath::Min(time [16+2*j],time [16+2*j+1]);
time2[16+j] = min_time;
if(min_time==0.0){time2[16+j]=TMath::Max(time[16+2*j],time[16+2*j+1]);}
virtual UInt_t Process(TMap* dcsAliasMap);
AliVZERODataDCS *fData; // CDB class that stores the data
+
+ private:
+ AliVZEROPreprocessor(const AliVZEROPreprocessor&); // Not implemented
+ AliVZEROPreprocessor& operator=(const AliVZEROPreprocessor&); // Not implemented
ClassDef(AliVZEROPreprocessor, 0);
};
//_____________________________________________________________________________
AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
TObject(stream),
+ fRawReader(stream.fRawReader),
fRawADC(stream.GetADCRaw()),
fADCModule(stream.GetADCModule()),
fADCChannel(stream.GetADCChannel()),