bool bDoPublishing=false;
const int cycleResetInterval=1000;
if (fpEventTimer && fpCycleTimer) {
- averageEventTime=(AliHLTUInt32_t)( (fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1) );
- fillingtime=(int)( fpEventTimer->RealTime()*fgkTimeScale );
+ averageEventTime=(fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1);
+ fillingtime=fpEventTimer->RealTime()*fgkTimeScale;
publishtime=fillingtime;
fpEventTimer->Start(kFALSE);
fpCycleTimer->Stop();
- averageCycleTime=(AliHLTUInt32_t)( (fpCycleTimer->RealTime()*fgkTimeScale)/((GetEventCount()%cycleResetInterval)+1) );
+ averageCycleTime=(fpCycleTimer->RealTime()*fgkTimeScale)/((GetEventCount()%cycleResetInterval)+1);
// adapt processing to 3/4 of the max time
bDoFilling=4*averageEventTime<3*fMaxEventTime ||
(averageEventTime<fCycleTimeFactor*averageCycleTime && fpCycleTimer->RealTime()>fIgnoreCycleTime);
}
if (fpEventTimer) {
fpEventTimer->Stop();
- fillingtime=(int) ( fpEventTimer->RealTime()*fgkTimeScale-fillingtime );
+ fillingtime=fpEventTimer->RealTime()*fgkTimeScale-fillingtime;
if (fillingtime<0) fillingtime=0;
fpEventTimer->Start(kFALSE);
}
if (fpEventTimer) {
fpEventTimer->Stop();
- publishtime=(int) ( fpEventTimer->RealTime()*fgkTimeScale-publishtime );
+ publishtime=fpEventTimer->RealTime()*fgkTimeScale-publishtime;
if (publishtime>fillingtime) publishtime-=fillingtime;
else publishtime=0;
- averageEventTime=(AliHLTUInt32_t)( (fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1) );
+ averageEventTime=(fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1);
// info output once every 5 seconds
static UInt_t lastTime=0;
AliHLTUInt32_t proctime=0;
if (fpEventTimer) {
- averageEventTime=(AliHLTUInt32_t)( (fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1) );
- proctime=(AliHLTUInt32_t)( fpEventTimer->RealTime()*fgkTimeScale );
+ averageEventTime=(fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1);
+ proctime=fpEventTimer->RealTime()*fgkTimeScale;
fpEventTimer->Start(kFALSE);
}
if (fpCycleTimer) {
fpCycleTimer->Stop();
- averageCycleTime=(AliHLTUInt32_t)( (fpCycleTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1) );
+ averageCycleTime=(fpCycleTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1);
}
// scale down the event processing according to the required rate
if (fpEventTimer) {
fpEventTimer->Stop();
- proctime=(AliHLTUInt32_t)( fpEventTimer->RealTime()*fgkTimeScale-proctime );
- averageEventTime=(AliHLTUInt32_t)( (fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1) );
+ proctime=fpEventTimer->RealTime()*fgkTimeScale-proctime;
+ averageEventTime=(fpEventTimer->RealTime()*fgkTimeScale)/(GetEventCount()+1);
// info output once every 2 seconds
static UInt_t lastTime=0;
TObject* pObj=msg.ReadObject(objclass);
if (!(fIsObject=(pObj!=NULL))) return NULL;
sw.Stop();
- AliHLTUInt32_t usec=(AliHLTUInt32_t)( sw.RealTime()*fgkTimeScale );
+ AliHLTUInt32_t usec=sw.RealTime()*fgkTimeScale;
fNofExtractions++;
fExtractionTimeUsec+=usec;
TTimeStamp ts;
sw.Start();
msg.WriteObject(obj);
- AliHLTUInt32_t usec=(AliHLTUInt32_t)( sw.RealTime()*fgkTimeScale );
+ AliHLTUInt32_t usec=sw.RealTime()*fgkTimeScale;
fNofStreamings++;
fStreamingTimeUsec+=usec;
TTimeStamp ts;
AliHLTCaloClusterizer::CompareDigitsByEnergy(const void *dig0, const void *dig1)\r
{\r
// See header file for documentation\r
- return (Int_t)( (*((AliHLTCaloDigitDataStruct**)(dig1)))->fEnergy - (*((AliHLTCaloDigitDataStruct**)(dig0)))->fEnergy );\r
+ return (*((AliHLTCaloDigitDataStruct**)(dig1)))->fEnergy - (*((AliHLTCaloDigitDataStruct**)(dig0)))->fEnergy;\r
}\r
// merge histos
- for ( unsigned int jColl = 0; jColl<fStore.size(); jColl++) {
- AliHLTGlobalHCCollection &c = fStore[jColl];
+ for ( unsigned int iColl = 0; iColl<fStore.size(); iColl++) {
+ AliHLTGlobalHCCollection &c = fStore[iColl];
if ( !c.fNeedToMerge && c.fMergedObject ) continue;
if ( c.fInstances.size() <1 ) continue;
delete c.fMergedObject;
if(zoom)
{
TH1F *h = dynamic_cast<TH1F*>(hist);
- h->GetXaxis()->SetRange(0, (Int_t)(h->GetMaximumBin() + h->GetMaximumBin()*0.2));
+ h->GetXaxis()->SetRange(0, h->GetMaximumBin() + h->GetMaximumBin()*0.2);
}
dynamic_cast<TH1F*>(hist)->Draw();
}
if(zoom)
{
TH2F *h = dynamic_cast<TH2F*>(hist);
- h->GetXaxis()->SetRange(0, (Int_t)(h->GetMaximumBin() + h->GetMaximumBin()*0.2));
- h->GetYaxis()->SetRange(0, (Int_t)(h->GetMaximumBin() + h->GetMaximumBin()*0.2));
+ h->GetXaxis()->SetRange(0, h->GetMaximumBin() + h->GetMaximumBin()*0.2);
+ h->GetYaxis()->SetRange(0, h->GetMaximumBin() + h->GetMaximumBin()*0.2);
}
dynamic_cast<TH2F*>(hist)->Draw("COLZ");
}
//##################################################################################
AliHLTJETConeJetCandidate::AliHLTJETConeJetCandidate() :
- fSeedCellIdx(0),
- fSeedEtaIdx(0),
- fSeedPhiIdx(0),
+ fSeedCellIdx(0.),
+ fSeedEtaIdx(0.),
+ fSeedPhiIdx(0.),
fSeedEta(0.),
fSeedPhi(0.),
fSeedPt(0.),
{
if (++i >= argc) return -EPROTO;
argument = argv[i];
- dynamic_cast<AliHLTCaloClusterizerNbyN*>(fClusterizerPtr)->SetGridDimension(argument.Atoi());
+ dynamic_cast<AliHLTCaloClusterizerNbyN*>(fClusterizerPtr)->SetGridDimension(argument.Atof());
return 1;
}
}
if(nESDTracks)
- nClsOffline = (Int_t)( Float_t(nClsOffline)/Float_t(nESDTracks) );
+ nClsOffline /= Float_t(nESDTracks);
if(nHLTesdTracks)
- nClsHLT = (Int_t)( Float_t(nClsHLT)/ Float_t(nHLTesdTracks) );
+ nClsHLT /= Float_t(nHLTesdTracks);
GetESDsData(kNCls)->Fill(nClsOffline, nClsHLT);
if (argument.CompareTo("-event-modulo")==0) {
if (++i>=argc) return -EPROTO;
argument=argv[i];
- fEvtMod=argument.Atoi();
+ fEvtMod=argument.Atof();
return 2;
}
if (argument.CompareTo("-buffer-size")==0) {
if (++i>=argc) return -EPROTO;
argument=argv[i];
- fBufferSize=argument.Atoi();
+ fBufferSize=argument.Atof();
return 2;
}
{
//Update the data pointer to the next padrow in memory.
- Byte_t *tmp = reinterpret_cast<Byte_t*>(tempPt);
+ Byte_t *tmp = (Byte_t*)tempPt;
Int_t size = sizeof(AliHLTTPCDigitRowData) + tempPt->fNDigit*sizeof(AliHLTTPCDigitData);
tmp += size;
- tempPt = reinterpret_cast<AliHLTTPCDigitRowData*>(tmp);
+ tempPt = (AliHLTTPCDigitRowData*)tmp;
}
Int_t AliHLTTPCMemHandler::ComparePoints(UInt_t /*row*/,UShort_t pad,UShort_t time) const
if (argument.CompareTo("-output-size")==0) {
if (++i>=argc) return -EPROTO;
argument=argv[i];
- fOutputSize=(AliHLTUInt32_t)argument.Atoi();
+ fOutputSize=argument.Atof();
return 2;
}
return -EINVAL;