void FRichCurve::ReadjustTimeRange(float NewMinTimeRange, float NewMaxTimeRange, bool bInsert/* whether insert or remove*/, float OldStartTime, float OldEndTime)
{
// first readjust modified time keys
float ModifiedDuration = OldEndTime - OldStartTime;
if (bInsert)
{
for(int32 KeyIndex=0; KeyIndex<Keys.Num(); ++KeyIndex)
{
float& CurrentTime = Keys[KeyIndex].Time;
if (CurrentTime >= OldStartTime)
{
CurrentTime += ModifiedDuration;
}
}
}
else
{
// since we only allow one key at a given time, we will just cache the value that needs to be saved
// this is the key to be replaced when this section is gone
bool bAddNewKey = false;
float NewValue = 0.f;
TArray<int32> KeysToDelete;
for(int32 KeyIndex=0; KeyIndex<Keys.Num(); ++KeyIndex)
{
float& CurrentTime = Keys[KeyIndex].Time;
// if this key exists between range of deleted
// we'll evaluate the value at the "OldStartTime"
// and re-add key, so that it keeps the previous value at the
// start time
// But that means if there are multiple keys,
// since we don't want multiple values in the same time
// the last one will override the value
if( CurrentTime >= OldStartTime && CurrentTime <= OldEndTime)
{
// get new value and add new key on one of OldStartTime, OldEndTime;
// this is a bit complicated problem since we don't know if OldStartTime or OldEndTime is preferred.
// generall we use OldEndTime unless OldStartTime == 0.f
// which means it's cut in the beginning. Otherwise it will always use the end time.
bAddNewKey = true;
if (OldStartTime != 0.f)
{
NewValue = Eval(OldStartTime);
}
else
{
NewValue = Eval(OldEndTime);
}
// remove this key, but later because it might change eval result
KeysToDelete.Add(KeyIndex);
}
else if (CurrentTime > OldEndTime)
{
CurrentTime -= ModifiedDuration;
}
}
if (bAddNewKey)
{
for (auto KeyIndex : KeysToDelete)
{
const FKeyHandle* KeyHandle = KeyHandlesToIndices.FindKey(KeyIndex);
if(KeyHandle)
{
DeleteKey(*KeyHandle);
}
}
UpdateOrAddKey(OldStartTime, NewValue);
}
}
// now remove all redundant key
TArray<FRichCurveKey> NewKeys;
Exchange(NewKeys, Keys);
for(int32 KeyIndex=0; KeyIndex<NewKeys.Num(); ++KeyIndex)
{
UpdateOrAddKey(NewKeys[KeyIndex].Time, NewKeys[KeyIndex].Value);
}
// now cull out all out of range
float MinTime, MaxTime;
GetTimeRange(MinTime, MaxTime);
bool bNeedToDeleteKey=false;
// if there is key below min time, just add key at new min range,
if (MinTime < NewMinTimeRange)
{
float NewValue = Eval(NewMinTimeRange);
UpdateOrAddKey(NewMinTimeRange, NewValue);
bNeedToDeleteKey = true;
}
// if there is key after max time, just add key at new max range,
if(MaxTime > NewMaxTimeRange)
{
float NewValue = Eval(NewMaxTimeRange);
UpdateOrAddKey(NewMaxTimeRange, NewValue);
bNeedToDeleteKey = true;
}
// delete the keys outside of range
if (bNeedToDeleteKey)
{
for (int32 KeyIndex=0; KeyIndex<Keys.Num(); ++KeyIndex)
{
if (Keys[KeyIndex].Time < NewMinTimeRange || Keys[KeyIndex].Time > NewMaxTimeRange)
{
const FKeyHandle* KeyHandle = KeyHandlesToIndices.FindKey(KeyIndex);
if (KeyHandle)
{
DeleteKey(*KeyHandle);
--KeyIndex;
}
}
}
}
}
int LinkTimeControl::PaintFCurves( ParamDimensionBase *dim, HDC hdc, Rect& rcGraph, Rect& rcPaint,
float tzoom, int tscroll, float vzoom, int vscroll, DWORD flags )
{
const int n = NumKeys();
if ( n == 0 )
return 0;
Interval valid;
int h = rcGraph.h()-1;
HPEN dpen,spen;
BOOL init=FALSE;
Interval range = GetTimeRange(TIMERANGE_ALL);
SetBkMode(hdc,TRANSPARENT);
dpen = CreatePen(PS_DOT,0,GetColorManager()->GetColor(kFunctionCurveFloat));
spen = CreatePen(PS_SOLID,0,GetColorManager()->GetColor(kFunctionCurveFloat));
SIZE size;
GetTextExtentPoint( hdc, _T("0"), 1, &size );
float val;
TimeValue leftTime = ScreenToTime(rcPaint.left,tzoom,tscroll);
TimeValue rightTime = ScreenToTime(rcPaint.right,tzoom,tscroll);
int x, y;
// dotted line to left of keys
if ( leftTime < range.Start() )
{
SelectObject(hdc,dpen);
GetValue(range.Start(),&val,valid);
y = ValueToScreen(dim->Convert(val),h,vzoom,vscroll);
MoveToEx(hdc,rcPaint.left,y,NULL);
LineTo(hdc,TimeToScreen(range.Start(),tzoom,tscroll),y);
}
SelectObject(hdc,spen);
// first node text
{
TimeValue t = GetKeyTime( 0 );
if ( t >= leftTime && t <= rightTime )
{
GetValue(t,&val,valid);
y = ValueToScreen(dim->Convert(val),h,vzoom,vscroll);
x = TimeToScreen(t,tzoom,tscroll);
INode* node = fOwner->GetNode( 0 );
DLTextOut( hdc, x, y-1-size.cy, node ? node->GetName() : _T("World") );
}
}
// solid line between keys
for ( int i=1; i<n; ++i )
{
TimeValue t0 = GetKeyTime( i-1 );
TimeValue t1 = GetKeyTime( i );
if ( t1 < leftTime || t0 > rightTime )
continue;
GetValue(t0,&val,valid);
y = ValueToScreen(dim->Convert(val),h,vzoom,vscroll);
MoveToEx(hdc,TimeToScreen(t0,tzoom,tscroll),y,NULL);
x = TimeToScreen(t1,tzoom,tscroll);
LineTo(hdc,x,y);
GetValue(t1,&val,valid);
y = ValueToScreen(dim->Convert(val),h,vzoom,vscroll);
LineTo(hdc,x,y);
INode* node = fOwner->GetNode( i );
DLTextOut( hdc, x, y-1-size.cy, node ? node->GetName() : _T("World") );
}
// dotted line to right of keys
if ( rightTime > range.End() )
{
SelectObject(hdc,dpen);
GetValue(range.End(),&val,valid);
y = ValueToScreen(dim->Convert(val),h,vzoom,vscroll);
MoveToEx(hdc,TimeToScreen(range.End(),tzoom,tscroll),y,NULL);
LineTo(hdc,rcPaint.right,y);
}
SelectObject( hdc, spen );
HBRUSH hUnselBrush = CreateSolidBrush(GetColorManager()->GetColor(kTrackbarKeys));
HBRUSH hSelBrush = CreateSolidBrush(GetColorManager()->GetColor(kTrackbarSelKeys));
// render keys themselves
for ( int i=0; i<n; ++i )
{
TimeValue t = GetKeyTime( i );
if ( t < leftTime || t > rightTime )
continue;
GetValue(t,&val,valid);
y = ValueToScreen(dim->Convert(val),h,vzoom,vscroll);
x = TimeToScreen(t,tzoom,tscroll);
SelectObject( hdc, IsKeySelected( i ) ? hSelBrush : hUnselBrush );
Rectangle(hdc,x-3,y-3,x+3,y+3);
}
SetBkMode(hdc,OPAQUE);
SelectObject(hdc,GetStockObject(BLACK_PEN));
DeleteObject(spen);
DeleteObject(dpen);
DeleteObject(hUnselBrush);
DeleteObject(hSelBrush);
return 0;
}
//_________________________________________________________________________________________________
void OccupancyInTimeBins(const char* input, const char* output)
{
timeResolutions.push_back(1);
timeResolutions.push_back(10);
timeResolutions.push_back(100);
AliRawReader* rawReader = AliRawReader::Create(input);
AliMUONRawStreamTrackerHP stream(rawReader);
stream.DisableWarnings();
stream.TryRecover(kTRUE);
int numberOfUsedEvents(0);
int numberOfBadEvents(0);
int numberOfEvents(0);
int numberOfPhysicsEvent(0);
int numberOfCalibrationEvent(0);
int numberOfEventsWithMCH(0);
int numberOfEventsWithoutCDH(0);
int runNumber(-1);
time_t runStart, runEnd;
AliMergeableCollection* hc(0x0);
AliCDBManager* cdbm = AliCDBManager::Instance();
if (!cdbm->IsDefaultStorageSet())
{
cdbm->SetDefaultStorage("local:///cvmfs/alice-ocdb.cern.ch/calibration/data/2015/OCDB");
}
cdbm->SetRun(0);
AliMpCDB::LoadAll();
while (rawReader->NextEvent() ) //&& numberOfEvents < 1000 )
{
rawReader->Reset();
++numberOfEvents;
if ( !rawReader->GetDataHeader() )
{
++numberOfEventsWithoutCDH;
}
if (rawReader->GetType() != AliRawEventHeaderBase::kPhysicsEvent)
{
if ( rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent )
{
++numberOfCalibrationEvent;
}
continue;
}
if (runNumber<0)
{
runNumber = rawReader->GetRunNumber();
GetTimeRange(runNumber,runStart,runEnd);
hc = new AliMergeableCollection("occ");
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
FillCollection(*hc,runStart,runEnd,timeResolutions[is]);
}
FillNumberOfPads(*hc);
}
++numberOfPhysicsEvent;
if ( numberOfPhysicsEvent % 5000 == 0 )
cout << Form("%12d events processed : %12d physics %d used ones %d bad ones [ %d with MCH information ]",
numberOfEvents,numberOfPhysicsEvent,numberOfUsedEvents,numberOfBadEvents,numberOfEventsWithMCH) << endl;
Bool_t mchThere(kFALSE);
for ( int iDDL = 0; iDDL < AliDAQ::NumberOfDdls("MUONTRK") && !mchThere; ++iDDL )
{
rawReader->Reset();
rawReader->Select("MUONTRK",iDDL,iDDL);
if (rawReader->ReadHeader() )
{
if (rawReader->GetEquipmentSize() ) mchThere = kTRUE;
}
}
if ( mchThere)
{
++numberOfEventsWithMCH;
}
else
{
continue;
}
Int_t buspatchId;
UShort_t manuId;
UChar_t manuChannel;
UShort_t adc;
stream.First();
std::map<int,int> bpValues;
while ( stream.Next(buspatchId,manuId,manuChannel,adc,kTRUE) )
{
bpValues[buspatchId]++;
}
for ( std::map<int,int>::const_iterator it = bpValues.begin(); it != bpValues.end(); ++it )
{
const int& buspatchId = it->first;
const int& bpvalue = it->second;
TString bpName = Form("BP%04d",buspatchId);
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
TH1* h = hc->Histo(Form("/BUSPATCH/HITS/%ds/%s",timeResolutions[is],bpName.Data()));
if (!h)
{
cout << "histogram not found" << endl;
continue;
}
h->Fill(rawReader->GetTimestamp(),bpvalue);
}
}
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
TH1* h = hc->Histo(Form("Nevents%ds",timeResolutions[is]));
if (!h)
{
cout << "histogram not found" << endl;
continue;
}
h->Fill(rawReader->GetTimestamp());
}
}
// Group BP histograms per DE then DDL then Chamber then Station
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
GroupByDE(*hc,timeResolutions[is]);
GroupByDDL(*hc,timeResolutions[is]);
GroupByChamber(*hc,timeResolutions[is]);
GroupByStation(*hc,timeResolutions[is]);
}
// make normalized versions of the histograms
Normalize(*hc);
TFile* fout = new TFile(output,"RECREATE");
hc->Write("occ");
delete fout;
}