//------------------------------------------------------------------------------
bool CvDatabaseUtility::PopulateArrayByExistence(int*& pArray, const char* szTypeTableName, const char* szDataTableName, const char* szTypeColumn, const char* szFilterColumn, const char* szFilterValue)
{
InitializeArray(pArray, MaxRows(szTypeTableName), -1);
std::string strKey = "_PABE_";
strKey.append(szTypeTableName);
strKey.append(szDataTableName);
strKey.append(szFilterColumn);
Database::Results* pResults = GetResults(strKey);
if(pResults == NULL)
{
char szSQL[512];
sprintf_s(szSQL, "select %s.ID from %s inner join %s on %s = %s.Type where %s = ?", szTypeTableName, szDataTableName, szTypeTableName, szTypeColumn, szTypeTableName, szFilterColumn);
pResults = PrepareResults(strKey, szSQL);
if(pResults == NULL)
return false;
}
if(!pResults->Bind(1, szFilterValue, false))
{
CvAssertMsg(false, GetErrorMessage());
return false;
}
int idx = 0;
while(pResults->Step())
{
pArray[idx++] = pResults->GetInt(0);
}
pResults->Reset();
return true;
}
void PreviewHandler::handlePendingReady ()
{
auto pending = qobject_cast<Media::IPendingAudioSearch*> (sender ());
QList<Phonon::MediaSource> sources;
QSet<QUrl> urls;
QSet<SamenessCheckInfo> infos;
for (const auto& res : pending->GetResults ())
{
if (urls.contains (res.Source_))
continue;
urls.insert (res.Source_);
const SamenessCheckInfo checkInfo
{
res.Info_.Album_.toLower ().trimmed (),
res.Info_.Title_.toLower ().trimmed (),
res.Info_.Length_
};
if (infos.contains (checkInfo))
continue;
infos << checkInfo;
Player_->PrepareURLInfo (res.Source_, MediaInfo::FromAudioInfo (res.Info_));
sources << Phonon::MediaSource (res.Source_);
}
if (!sources.isEmpty ())
Player_->Enqueue (sources, false);
CheckPendingAlbum (pending);
}
void FObjectMemoryAnalyzer::PrintResults(FOutputDevice& Ar, uint32 PrintFlags)
{
TArray<FObjectMemoryUsage> Results;
GetResults(Results);
Results.Sort(FCompareFSortBySize(ESortKey::InclusiveTotal));
Ar.Logf( TEXT("%-100s %-10s %-10s %-10s %-10s"), TEXT("Object"), TEXT("InclBytes"), TEXT("ExclBytes"), TEXT("InclResKBytes"), TEXT("ExclResKBytes") );
for( int32 i=0; i < Results.Num(); ++i )
{
const FObjectMemoryUsage& Annotation = Results[i];
if (Annotation.IsRoot() || (Annotation.RootReferencer.Num() == 0 && Annotation.NonRootReferencer.Num() == 0) )
{
Ar.Logf( TEXT("%-100s %-10d %-10d %-10d %-10d"), *FString::Printf(TEXT("%s %s"), *Annotation.Object->GetClass()->GetName(), *Annotation.Object->GetName()),
(int32)Annotation.InclusiveMemoryUsage, (int32)Annotation.ExclusiveMemoryUsage,
(int32)(Annotation.InclusiveResourceSize/1024), (int32)(Annotation.ExclusiveResourceSize/1024) );
if (!!(PrintFlags&EPrintFlags::PrintReferences))
{
PrintSubObjects(Ar, TEXT(" -> "), Annotation.Object, PrintFlags);
}
}
}
}
void MyVisitor::printData() {
std::vector<SpatialIndex::IData*>::iterator it;
//int len = 0;
char buf[1024];
for(it = GetResults().begin(); it != GetResults().end(); it++) {
byte* pData = 0;
uint32_t len = 0;
(*it)->getData(len, &pData);
//#ifdef WRITE_LOG
memset(buf, 0, 1024);
int t_id;
memcpy(&t_id, pData, sizeof(int));
sprintf(buf, "%d\n", t_id);
write_log(RESULT_LOG, buf);
delete[] pData;
//#endif
}
}
//------------------------------------------------------------------------------
void CvDatabaseUtility::ClearResults(const std::string& strKey)
{
Database::Results* pResults = GetResults(strKey);
if(pResults)
{
delete pResults;
m_storedResults.erase(strKey);
}
}
int CTDLFindResultsListCtrl::GetResultIDs(const CFilteredToDoCtrl* pTDC, CDWordArray& aTaskIDs) const
{
CFTDResultsArray aResults;
int nNumRes = GetResults(pTDC, aResults);
for (int nRes = 0; nRes < nNumRes; nRes++)
aTaskIDs.Add(aResults[nRes].dwTaskID);
return aResults.GetSize();
}
void SAutomationExportMenu::HandleMenuOpen()
{
// Get the results from the automation controller
GetResults();
// Set all flags is Set All is selected
if ( EFileExportType::IsSet( FileExportTypeMask, EFileExportType::FET_All ) )
{
EnableAvailableReports();
}
// Create the menu items
CreateMenu();
}
bool ResultLog::SaveAvailabilityResults( wxString filename, bool _export )
{
// The availability results
Result *r = GetResults( wxString(wxT("availability")) );
wxFileOutputStream output_avail( filename );
wxTextOutputStream text_avail( output_avail );
int ColumnCount = (_export ? r->GetColumnCount() -2 : r->GetColumnCount());
wxString strHeader;
if( _export )
{
this->m_SaveDelimiter = wxT(",");
StringValueList *header = r->GetHeader();
int countheader = 0;
for( StringValueList::Node *node = header->GetFirst() ; node && countheader++ < ColumnCount ; node = node->GetNext() )
{
strHeader << *node->GetData() << m_SaveDelimiter;
}
strHeader.SetChar( strHeader.Length()-1, wxT('\n') );
}
else
{
m_SaveDelimiter = wxT("\t");
}
text_avail.WriteString( strHeader );
for( int i = 0 ; i < r->GetRowCount() ; i++ )
{
StringValueList *row = r->GetRow( i );
wxString line;
int countcolumn = 0;
for( StringValueList::Node *node = row->GetFirst() ; node && countcolumn++ < ColumnCount ; node = node->GetNext() )
{
line << *node->GetData() << m_SaveDelimiter;
}
line.SetChar( line.Length()-1, wxT('\n') );
text_avail.WriteString( line );
}
return true;
}
bool ResultLog::SaveStandardResults( wxString filename, bool _export )
{
// The standard reslts
Result *r = GetResults( wxString(wxT("standard")) );
wxFileOutputStream output( filename );
wxTextOutputStream text( output );
wxString strHeader;
if( _export )
{
this->m_SaveDelimiter = wxT(",");
StringValueList *header = r->GetHeader();
for( StringValueList::Node *node = header->GetFirst() ; node ; node = node->GetNext() )
{
strHeader << *node->GetData() << m_SaveDelimiter;
}
strHeader.SetChar( strHeader.Length()-1, wxT('\n') );
}
else
{
m_SaveDelimiter = wxT("\t");
}
text.WriteString( strHeader );
for( int i = 0 ; i < r->GetRowCount() ; i++ )
{
StringValueList *row = r->GetRow( i );
wxString line;
for( StringValueList::Node *node = row->GetFirst() ; node ; node = node->GetNext() )
{
line << *node->GetData() << m_SaveDelimiter;
}
line.SetChar( line.Length()-1, wxT('\n') );
text.WriteString( line );
}
return true;
}
bool ResultLog::AddResult(wxString resultname, StringValueList &row)
{
AppConfig *ac = AppConfig::GetInstance();
wxString maxrows;
ac->GetValue( wxString(wxT("HISTORY_COUNT")), maxrows );
long imax;
maxrows.ToLong( &imax );
Result *r = GetResults( resultname );
if( r->GetRowCount() > imax-1 )
{
r->DeleteRow( 0 );
}
r->AddRow( row );
return false;
}
void XmlTestReporter::ReportSummary(int totalTestCount, int failedTestCount,
int failureCount, float secondsElapsed)
{
AddXmlElement(m_ostream, NULL);
BeginResults(m_ostream, totalTestCount, failedTestCount, failureCount, secondsElapsed);
DeferredTestResultList const& results = GetResults();
for (DeferredTestResultList::const_iterator i = results.begin(); i != results.end(); ++i)
{
BeginTest(m_ostream, *i);
if (i->failed)
AddFailure(m_ostream, *i);
EndTest(m_ostream, *i);
}
EndResults(m_ostream);
}
//------------------------------------------------------------------------------
Database::Results* CvDatabaseUtility::PrepareResults(const std::string& strKey, const char* szStmt)
{
Database::Results* pResults = new Database::Results();
if(DB.Execute(*pResults, szStmt))
{
Database::Results* pOldResults = GetResults(strKey);
if(pOldResults)
delete pOldResults;
m_storedResults[strKey] = pResults;
return pResults;
}
else
{
delete pResults;
}
return NULL;
}
//------------------------------------------------------------------------------
bool CvDatabaseUtility::PopulateArrayByValue(int*& pArray, const char* szTypeTableName, const char* szDataTableName, const char* szTypeColumn, const char* szFilterColumn, const char* szFilterValue, const char* szValueColumn, int iDefaultValue /* = 0 */, int iMinArraySize /* = 0 */)
{
int iSize = MaxRows(szTypeTableName);
InitializeArray(pArray, (iSize<iMinArraySize)?iMinArraySize:iSize, iDefaultValue);
std::string strKey = "_PABV_";
strKey.append(szTypeTableName);
strKey.append(szDataTableName);
strKey.append(szFilterColumn);
strKey.append(szValueColumn);
Database::Results* pResults = GetResults(strKey);
if(pResults == NULL)
{
char szSQL[512];
sprintf_s(szSQL, "select %s.ID, %s from %s inner join %s on %s = %s.Type where %s = ?", szTypeTableName, szValueColumn, szDataTableName, szTypeTableName, szTypeColumn, szTypeTableName, szFilterColumn);
pResults = PrepareResults(strKey, szSQL);
if(pResults == NULL)
return false;
}
if(!pResults->Bind(1, szFilterValue, false))
{
CvAssertMsg(false, GetErrorMessage());
return false;
}
while(pResults->Step())
{
const int idx = pResults->GetInt(0);
const int value = pResults->GetInt(1);
pArray[idx] = value;
}
pResults->Reset();
return true;
}
int CTDLFindResultsListCtrl::GetAllResults(CFTDResultsArray& aResults) const
{
return GetResults(NULL, aResults);
}
UINT_PTR CALLBACK AddSrcDlgProc95( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
WORD cmd;
int item;
LRESULT rc;
HWND ctl;
HWND dlg;
GetFilesInfo *info;
lparam = lparam;
switch( msg ) {
case WM_INITDIALOG:
{
OPENFILENAME *of;
of = (OPENFILENAME *)lparam;
ctl = GetDlgItem( hwnd, FOD_REMOVE );
EnableWindow( ctl, FALSE );
dlg = GetParent( hwnd );
SendMessage( dlg, CDM_SETCONTROLTEXT, IDOK, (LPARAM)"&Add" );
SET_DLGDATA( hwnd, of->lCustData );
info = (GetFilesInfo *)of->lCustData;
info->filter_index = of->nFilterIndex;
info->filter = of->lpstrFilter;
initFileList( hwnd );
}
break;
case WM_COMMAND:
cmd = LOWORD( wparam );
switch( cmd ) {
case FOD_ADD:
addCurrentFile95( hwnd );
return( TRUE );
case FOD_ADDALL:
addAllFiles95( hwnd );
break;
case FOD_REMOVE:
ctl = GetDlgItem( hwnd, FOD_FILELIST );
item = (int)SendMessage( ctl, LB_GETCURSEL, 0, 0 );
if( item != LB_ERR ) {
rc = SendMessage( ctl, LB_DELETESTRING, item, 0 );
if( item != 0 ) {
SendMessage( ctl, LB_SETCURSEL, item - 1, 0 );
} else {
SendMessage( ctl, LB_SETCURSEL, item, 0 );
}
}
checkRemoveButton( hwnd );
break;
case FOD_FILELIST:
if( GET_WM_COMMAND_CMD( wparam, lparam ) == LBN_SELCHANGE ||
GET_WM_COMMAND_CMD( wparam, lparam ) == LBN_SELCANCEL ) {
checkRemoveButton( hwnd );
}
break;
case FOD_CLOSE:
GetResults( hwnd );
info = (GetFilesInfo *)GET_DLGDATA( hwnd );
info->ret_code = IDOK;
PostMessage( GetParent( hwnd ), WM_COMMAND, IDCANCEL, 0L );
return( TRUE );
case IDCANCEL:
info = (GetFilesInfo *)GET_DLGDATA( hwnd );
info->ret_code = IDCANCEL;
PostMessage( GetParent( hwnd ), WM_COMMAND, IDCANCEL, 0L );
return( TRUE );
default:
return( FALSE );
}
break;
case WM_NOTIFY:
switch( ((NMHDR *)lparam)->code ) {
case CDN_FILEOK:
PostMessage( hwnd, WM_COMMAND, FOD_ADD, 0L );
SET_DLGRESULT( hwnd, 1L );
return( TRUE );
case CDN_TYPECHANGE:
info = (GetFilesInfo *)GET_DLGDATA( hwnd );
info->filter_index = ((OFNOTIFY *)lparam)->lpOFN->nFilterIndex;
break;
}
break;
default:
return( FALSE );
}
return( TRUE );
}
HRESULT CImplVulfix::Scan(DWORD dwFlags)
{
TIME_CHECK( _T("CImplVulfix::Scan ") );
m_Canceled = FALSE;
T_ComInit __init__com__;
HRESULT hr ;
do
{
Reset();
GetLangID();
CSysEnv& sysEnv = singleton<CSysEnv>::Instance();
sysEnv.Init();
if( FAILED( hr=sysEnv.IsSupported(FALSE) ) )
break;
Init();
m_objIgnore.LoadIgnoreDB();
CString filenameSystem, filenameOffice, filenameSoft;
GetXmlDBFileName(VTYPE_WINDOWS, filenameSystem, IsWin64());
GetXmlDBFileName(VTYPE_OFFICE, filenameOffice, FALSE);
GetXmlDBFileName(VTYPE_SOFTLEAK, filenameSoft, FALSE);
if( !PathFileExists(filenameSystem) && !PathFileExists(filenameOffice) && !PathFileExists(filenameSoft) )
{
hr = KERR_LOAD_FILE;
break;
}
m_pFilterOS = CreateOSFilter(sysEnv.m_WinVer, dwFlags);
InitOSFilter( m_pFilterOS, sysEnv.m_WinVer, dwFlags);
if( m_pFilterOS->WaitComplete() )
{
m_dbOS.SetObserver( m_Observer );
m_dbOffice.SetObserver( m_Observer );
m_dbSoft.SetObserver( m_Observer );
m_pFilterOS->SetIIgnore( &m_objIgnore );
CString filename;
try
{
FixLocale();
//BOOL bWin64 = IsWin64();
//PVOID OldValue = NULL;
//if(bWin64)
// Wow64DisableWow64FsRedirection(&OldValue);
!m_Canceled && m_dbOffice.Load( filenameOffice, m_pFilterOS, dwFlags );
!m_Canceled && sysEnv.IsLangSupported() && sysEnv.IsOsSupported() && m_dbOS.Load( filenameSystem, m_pFilterOS, dwFlags );
!m_Canceled && m_dbSoft.Load( filenameSoft, NULL, dwFlags);
//if(bWin64)
// Wow64RevertWow64FsRedirection(OldValue);
}
catch (...)
{
hr = KERR_LOAD_FILE;
}
CSimpleArray<LPTUpdateItem> arrLeaks;
CSimpleArray<TReplacedUpdate*> arrReplaced;
m_dbOS.GetUnfixedLeakList( arrLeaks, m_arrFixedVuls, m_arrInvalid, arrReplaced );
m_dbOffice.GetUnfixedLeakList( arrLeaks, m_arrFixedVuls, m_arrInvalid, arrReplaced );
const CSimpleArray<int> &arrExpired = m_dbOS.GetExpiredIds();
CSimpleArray<int> arrReplacedId;
for(int i=0; i<arrReplaced.GetSize(); ++i)
{
arrReplacedId.Add( arrReplaced[i]->nKBID );
}
// select soft ignored vuls
CSimpleArray<LPTVulSoft> arrSoftLeaks;
m_dbSoft.GetUnfixedLeakList( arrSoftLeaks );
for(int i=0; i<arrSoftLeaks.GetSize(); ++i)
{
LPTVulSoft ps = arrSoftLeaks[i];
ps->isIgnored = m_objIgnore.IsIgnored( ps->nID );
if( ps->isIgnored )
{
LPTUpdateItem pu = new TUpdateItem;
pu->m_nType = VTYPE_SOFTLEAK;
pu->nID = ps->nID;
pu->strName = ps->matchedItem.strName;
pu->strDescription = ps->strDescription;
pu->strWebpage = ps->matchedItem.strWebpage;
pu->nWarnLevel = ps->nLevel;
pu->strPubdate = ps->strPubdate;
m_arrIgnoredVuls.Add( pu );
m_arrIgnoredVulsFromSoft.Add( pu );
}
else
m_arrSoftLeaks.Add( ps );
}
// select installable, ignored , expired
for(int i=0; i<arrLeaks.GetSize(); ++i )
{
LPTUpdateItem &pi = arrLeaks[i];
pi->isExpired = arrExpired.Find( pi->nID )!=-1;
if(pi->isExpired)
m_arrInvalid.Add( pi );
else if(pi->isIgnored)
m_arrIgnoredVuls.Add( pi );
else
{
bool bReplaced = arrReplacedId.Find( pi->nID )!=-1;
if(!bReplaced)
m_arrLeaks.Add( pi );
}
}
// find correct replace relationship
for(int i=0; i<arrReplaced.GetSize(); ++i)
{
TReplacedUpdate* pu = arrReplaced[i];
BOOL bInstalled = FindArrayIndex( m_arrFixedVuls, pu->nKBID )!=-1;
if( !bInstalled )
{
if( FindArrayIndex(m_arrFixedVuls, pu->nKBID2)!=-1
|| FindArrayIndex(m_arrLeaks, pu->nKBID2)!=-1
|| FindArrayIndex(m_arrIgnoredVuls, pu->nKBID2)!=-1 )
m_arrReplacedUpdates.Add( pu );
}
}
// - 保存最后无漏洞时间, 使得下次不再提示有风险
// -- 非快速扫描的结果才有效果
if( RequireUsingInterface() && !(dwFlags & VULSCAN_EXPRESS_SCAN) )
{
BOOL hasMustLeak = FALSE;
const CSimpleArray<LPTUpdateItem> &arrLeaks = GetResults();
for(int i=0; i<arrLeaks.GetSize(); ++i)
{
if(arrLeaks[i]->nWarnLevel>0)
{
hasMustLeak = TRUE;
break;
}
}
CString strVal;
if(!hasMustLeak)
{
T_Date date;
GetLatestPackgeDate(date.nYear, date.nMonth, date.nDay);
strVal.Format(_T("%04d-%02d-%02d"), date.nYear, date.nMonth, date.nDay);
}
WriteVulConfig(_T("VulScan"), _T("LastSafePkgDate"), strVal);
}
}
hr = KERR_NONE;
} while (FALSE);
return hr;
}
void DrawEfficiencyCentralitySource(Int_t bincentrality,Int_t source,const char *testfile) {
//
// source: 0 (charm), 1 (beauty), 2 (gamma), 3 (others)
// centrality: from 0 to 100 with 0-5, 5-10, 10-15...
//
//
gStyle->SetPalette(1);
gStyle->SetOptStat(1111);
gStyle->SetPadBorderMode(0);
gStyle->SetCanvasColor(10);
gStyle->SetPadLeftMargin(0.13);
gStyle->SetPadRightMargin(0.13);
///////////////////////////////////
// Take the stuff
//////////////////////////////////
TList *results = GetResults(testfile,"");
if(!results){
printf("No output objects: Calculation will terminate here\n");
return;
}
AliHFEcontainer *containerhfe = (AliHFEcontainer *) results->FindObject("trackContainer");
if(!containerhfe) {
printf("No hfe container \n");
return;
}
// 0: pt, 1: eta, 2: phi, 3: charge, 4: source, 5: centrality
AliCFContainer *sumcontaineresdd = containerhfe->MakeMergedCFContainer("sumesd","sumesd","MCTrackCont:recTrackContReco");
AliCFContainer *sumcontainermcc = containerhfe->MakeMergedCFContainer("summc","summc","MCTrackCont:recTrackContMC");
if(!sumcontaineresdd) {
printf("No container sum esd\n");
return;
}
if(!sumcontainermcc) {
printf("No container sum mc\n");
return;
}
// 0: pt, 1: eta, 2: phi for a given centrality and source
//AliCFContainer *sumcontaineresd = GetContainerSourceCentrality(sumcontaineresdd,bincentrality,source);
//AliCFContainer *sumcontainermc = GetContainerSourceCentrality(sumcontainermcc,bincentrality,source);
// 0: pt, 1: eta, 2: phi, 3: centrality for a given centrality and source
AliCFContainer *sumcontaineresd = GetContainerSourceAsFunctionOfCentrality(sumcontaineresdd,source);
AliCFContainer *sumcontainermc = GetContainerSourceAsFunctionOfCentrality(sumcontainermcc,source);
Int_t nSteps = sumcontaineresd->GetNStep();
printf("In total %d steps\n",nSteps);
AliCFDataGrid *dataGrida = (AliCFDataGrid *) GetSpectrum(sumcontaineresdd,nSteps-1);
TH1D *spectrumcentrality = (TH1D *) dataGrida->Project(5);
TH1D *spectrumpt = (TH1D *) dataGrida->Project(0);
TH2D *spectrumptc = (TH2D *) dataGrida->Project(5,0);
TAxis *xaxis = spectrumptc->GetXaxis();
Int_t bin0 = xaxis->FindBin(0.0);
Int_t bin5_s = xaxis->FindBin(4.99);
Int_t bin30 = xaxis->FindBin(30.0);
Int_t bin40_s = xaxis->FindBin(39.9);
Int_t bin70 = xaxis->FindBin(70.0);
Int_t bin80_s = xaxis->FindBin(79.9);
printf("Bin 0 %d\n",bin0);
printf("Bin 5 %d\n",bin5_s);
printf("Bin 30 %d\n",bin30);
printf("Bin 40 %d\n",bin40_s);
printf("Bin 70 %d\n",bin70);
printf("Bin 80 %d\n",bin80_s);
TH1D *spectrumcentrality_0_5 = spectrumptc->ProjectionY("centrality_0_5",bin0,bin5_s);
TH1D *spectrumcentrality_30_40 = spectrumptc->ProjectionY("centrality_30_40",bin30,bin40_s);
TH1D *spectrumcentrality_70_80 = spectrumptc->ProjectionY("centrality_70_80",bin70,bin80_s);
Int_t numberOfEvents = (Int_t) containerhfe->GetNumberOfEvents();
printf("Number of events for a %d after Event cut\n",numberOfEvents);
////////////////////////////////
// Input after ITS&TPC refit
///////////////////////////////
TCanvas * canvascpt = new TCanvas("RawSpectrumCentrality","RawSpectrumCentrality",1000,700);
canvascpt->Divide(2,1);
canvascpt->cd(1);
spectrumpt->SetTitle("");
spectrumpt->SetStats(0);
spectrumpt->SetLineColor(kBlue);
spectrumpt->SetMarkerColor(kBlue);
spectrumpt->SetMarkerStyle(25);
//
spectrumcentrality_0_5->SetTitle("");
spectrumcentrality_0_5->SetStats(0);
spectrumcentrality_0_5->SetLineColor(kRed);
spectrumcentrality_0_5->SetMarkerColor(kRed);
spectrumcentrality_0_5->SetMarkerStyle(26);
//
spectrumcentrality_30_40->SetTitle("");
spectrumcentrality_30_40->SetStats(0);
spectrumcentrality_30_40->SetLineColor(kMagenta);
spectrumcentrality_30_40->SetMarkerColor(kBlack);
spectrumcentrality_30_40->SetMarkerStyle(27);
//
spectrumcentrality_70_80->SetTitle("");
spectrumcentrality_70_80->SetStats(0);
spectrumcentrality_70_80->SetLineColor(kBlue);
spectrumcentrality_70_80->SetMarkerColor(kBlue);
spectrumcentrality_70_80->SetMarkerStyle(28);
//
spectrumpt->Draw();
spectrumcentrality_0_5->Draw("same");
spectrumcentrality_30_40->Draw("same");
spectrumcentrality_70_80->Draw("same");
TLegend *leg_different_centralities = new TLegend(0.4,0.6,0.89,0.89);
leg_different_centralities->AddEntry(spectrumpt,"Minimum-bias","p");
leg_different_centralities->AddEntry(spectrumcentrality_0_5,"0_5","p");
leg_different_centralities->AddEntry(spectrumcentrality_30_40,"30_40","p");
leg_different_centralities->AddEntry(spectrumcentrality_70_80,"70_80","p");
leg_different_centralities->Draw("same");
canvascpt->cd(2);
spectrumptc->Draw("colz");
/////////////////////////////////////
// Take efficiencies
/////////////////////////////////////
AliCFEffGrid *efficiencystepkineITSTPC = (AliCFEffGrid*) GetEfficiency(sumcontaineresd,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecKineITSTPC,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecNoCut);
AliCFEffGrid *efficiencystepPrim = (AliCFEffGrid*) GetEfficiency(sumcontaineresd,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecPrim,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecKineITSTPC);
AliCFEffGrid *efficiencystepHFEcutsITS = (AliCFEffGrid*) GetEfficiency(sumcontaineresd,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsITS,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecPrim);
AliCFEffGrid *efficiencystepHFEcutsTRD = (AliCFEffGrid*) GetEfficiency(sumcontaineresd,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsITS);
AliCFEffGrid *efficiencystepPIDTOF = (AliCFEffGrid*) GetEfficiency(sumcontaineresd,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+1,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD);
AliCFEffGrid *efficiencystepPIDTPC = (AliCFEffGrid*) GetEfficiency(sumcontaineresd,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+2,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+1);
AliCFEffGrid *efficiencystepPIDall = (AliCFEffGrid*) GetEfficiency(sumcontaineresd,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+2,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD);
AliCFEffGrid *efficiencystepall = (AliCFEffGrid*) GetEfficiency(sumcontaineresd,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+2,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecNoCut);
//
AliCFEffGrid *efficiencystepMCkineITSTPC = (AliCFEffGrid*) GetEfficiency(sumcontainermc,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecKineITSTPC,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecNoCut);
AliCFEffGrid *efficiencystepMCPrim = (AliCFEffGrid*) GetEfficiency(sumcontainermc,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecPrim,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecKineITSTPC);
AliCFEffGrid *efficiencystepMCHFEcutsITS = (AliCFEffGrid*) GetEfficiency(sumcontainermc,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsITS,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepRecPrim);
AliCFEffGrid *efficiencystepMCHFEcutsTRD = (AliCFEffGrid*) GetEfficiency(sumcontainermc,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsITS);
AliCFEffGrid *efficiencystepMCPIDTOF = (AliCFEffGrid*) GetEfficiency(sumcontainermc,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+1,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD);
AliCFEffGrid *efficiencystepMCPIDTPC = (AliCFEffGrid*) GetEfficiency(sumcontainermc,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+2,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+1);
AliCFEffGrid *efficiencystepMCPIDall = (AliCFEffGrid*) GetEfficiency(sumcontainermc,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+2,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD);
AliCFEffGrid *efficiencystepMCall = (AliCFEffGrid*) GetEfficiency(sumcontainermc,AliHFEcuts::kNcutStepsMCTrack+AliHFEcuts::kStepHFEcutsTRD+2,0);
///////////////////////////////////////
// Plot 1D
///////////////////////////////////////
/////////////////////
// Different cuts
/////////////////////
TCanvas * canvascomparison = new TCanvas("ITSTPCrefitStepESD","ITSTPCrefitStepESD",1000,700);
canvascomparison->Divide(2,2);
canvascomparison->cd(1);
TH2D* h_effsteponlykineITSTPC1Donly = (TH2D *) efficiencystepkineITSTPC->Project(0,3);
h_effsteponlykineITSTPC1Donly->SetTitle("");
h_effsteponlykineITSTPC1Donly->SetStats(0);
h_effsteponlykineITSTPC1Donly->SetLineColor(kBlue);
h_effsteponlykineITSTPC1Donly->SetMarkerColor(kBlue);
h_effsteponlykineITSTPC1Donly->SetMarkerStyle(25);
h_effsteponlykineITSTPC1Donly->Draw("colz");
canvascomparison->cd(2);
TH2D* h_effsteponlyPrim1Donly =( TH2D *) efficiencystepPrim->Project(0,3);
h_effsteponlyPrim1Donly->SetTitle("");
h_effsteponlyPrim1Donly->SetStats(0);
h_effsteponlyPrim1Donly->SetLineColor(kBlue);
h_effsteponlyPrim1Donly->SetMarkerColor(kBlue);
h_effsteponlyPrim1Donly->SetMarkerStyle(25);
h_effsteponlyPrim1Donly->Draw("colz");
canvascomparison->cd(3);
TH2D* h_effsteponlyHFEcutsITS1Donly = (TH2D *) efficiencystepHFEcutsITS->Project(0,3);
h_effsteponlyHFEcutsITS1Donly->SetTitle("");
h_effsteponlyHFEcutsITS1Donly->SetStats(0);
h_effsteponlyHFEcutsITS1Donly->SetLineColor(kBlue);
h_effsteponlyHFEcutsITS1Donly->SetMarkerColor(kBlue);
h_effsteponlyHFEcutsITS1Donly->SetMarkerStyle(25);
h_effsteponlyHFEcutsITS1Donly->Draw("colz");
canvascomparison->cd(4);
TH2D* h_effsteponlyPID1Donly = (TH2D *) efficiencystepHFEcutsTRD->Project(0,3);
h_effsteponlyPID1Donly->SetTitle("");
h_effsteponlyPID1Donly->SetStats(0);
h_effsteponlyPID1Donly->SetLineColor(kBlue);
h_effsteponlyPID1Donly->SetMarkerColor(kBlue);
h_effsteponlyPID1Donly->SetMarkerStyle(25);
h_effsteponlyPID1Donly->Draw("colz");
/////////////////////
// Different cuts
/////////////////////
TCanvas * canvascomparisonbis = new TCanvas("ITSTPCrefitStepMC","ITSTPCrefitStepMC",1000,700);
canvascomparisonbis->Divide(2,2);
canvascomparisonbis->cd(1);
TH2D* h_effstepMCkineITSTPC1Donly = (TH2D *)efficiencystepMCkineITSTPC->Project(0,3);
h_effstepMCkineITSTPC1Donly->SetTitle("");
h_effstepMCkineITSTPC1Donly->SetStats(0);
h_effstepMCkineITSTPC1Donly->SetLineColor(kBlue);
h_effstepMCkineITSTPC1Donly->SetMarkerColor(kBlue);
h_effstepMCkineITSTPC1Donly->SetMarkerStyle(25);
h_effstepMCkineITSTPC1Donly->Draw("colz");
canvascomparisonbis->cd(2);
TH2D* h_effstepMCPrim1Donly = (TH2D *) efficiencystepMCPrim->Project(0,3);
h_effstepMCPrim1Donly->SetTitle("");
h_effstepMCPrim1Donly->SetStats(0);
h_effstepMCPrim1Donly->SetLineColor(kBlue);
h_effstepMCPrim1Donly->SetMarkerColor(kBlue);
h_effstepMCPrim1Donly->SetMarkerStyle(25);
h_effstepMCPrim1Donly->Draw("colz");
canvascomparisonbis->cd(3);
TH2D* h_effstepMCHFEcutsITS1Donly = (TH2D *) efficiencystepMCHFEcutsITS->Project(0,3);
h_effstepMCHFEcutsITS1Donly->SetTitle("");
h_effstepMCHFEcutsITS1Donly->SetStats(0);
h_effstepMCHFEcutsITS1Donly->SetLineColor(kBlue);
h_effstepMCHFEcutsITS1Donly->SetMarkerColor(kBlue);
h_effstepMCHFEcutsITS1Donly->SetMarkerStyle(25);
h_effstepMCHFEcutsITS1Donly->Draw("colz");
canvascomparisonbis->cd(4);
TH2D* h_effstepMCPID1Donly = (TH2D *) efficiencystepMCHFEcutsTRD->Project(0,3);
h_effstepMCPID1Donly->SetTitle("");
h_effstepMCPID1Donly->SetStats(0);
h_effstepMCPID1Donly->SetLineColor(kBlue);
h_effstepMCPID1Donly->SetMarkerColor(kBlue);
h_effstepMCPID1Donly->SetMarkerStyle(25);
h_effstepMCPID1Donly->Draw("colz");
///////////
// PID
///////////
TCanvas * canvasc1Don = new TCanvas("PIDstepESD","PIDstepESD",1000,700);
canvasc1Don->Divide(3,1);
canvasc1Don->cd(1);
TH2D* h_effstepPID1Donly = (TH2D *) efficiencystepPIDTOF->Project(0,3);
h_effstepPID1Donly->SetTitle("");
h_effstepPID1Donly->SetStats(0);
h_effstepPID1Donly->SetLineColor(kBlue);
h_effstepPID1Donly->SetMarkerColor(kBlue);
h_effstepPID1Donly->SetMarkerStyle(25);
gPad->SetLogz();
h_effstepPID1Donly->Draw("colz");
canvasc1Don->cd(2);
TH2D* h_effstepPID1Donlyy = (TH2D *) efficiencystepPIDTPC->Project(0,3);
h_effstepPID1Donlyy->SetTitle("");
h_effstepPID1Donlyy->SetStats(0);
h_effstepPID1Donlyy->SetLineColor(kBlue);
h_effstepPID1Donlyy->SetMarkerColor(kBlue);
h_effstepPID1Donlyy->SetMarkerStyle(25);
gPad->SetLogz();
h_effstepPID1Donlyy->Draw("colz");
canvasc1Don->cd(3);
TH2D* h_effstepPID1Donlyyy = (TH2D *) efficiencystepPIDall->Project(0,3);
h_effstepPID1Donlyyy->SetTitle("");
h_effstepPID1Donlyyy->SetStats(0);
h_effstepPID1Donlyyy->SetLineColor(kBlue);
h_effstepPID1Donlyyy->SetMarkerColor(kBlue);
h_effstepPID1Donlyyy->SetMarkerStyle(25);
gPad->SetLogz();
h_effstepPID1Donlyyy->Draw("colz");
//
TCanvas * canvasc1DonMC = new TCanvas("PIDstepMC","PIDstepMC",1000,700);
canvasc1DonMC->Divide(3,1);
canvasc1DonMC->cd(1);
TH2D* h_effstepPID1DMConly = (TH2D *) efficiencystepMCPIDTOF->Project(0,3);
h_effstepPID1DMConly->SetTitle("");
h_effstepPID1DMConly->SetStats(0);
h_effstepPID1DMConly->SetLineColor(kBlue);
h_effstepPID1DMConly->SetMarkerColor(kBlue);
h_effstepPID1DMConly->SetMarkerStyle(25);
gPad->SetLogz();
h_effstepPID1DMConly->Draw("colz");
canvasc1DonMC->cd(2);
TH2D* h_effstepPID1DMConlyy = (TH2D *) efficiencystepMCPIDTPC->Project(0,3);
h_effstepPID1DMConlyy->SetTitle("");
h_effstepPID1DMConlyy->SetStats(0);
h_effstepPID1DMConlyy->SetLineColor(kBlue);
h_effstepPID1DMConlyy->SetMarkerColor(kBlue);
h_effstepPID1DMConlyy->SetMarkerStyle(25);
gPad->SetLogz();
h_effstepPID1DMConlyy->Draw("colz");
canvasc1DonMC->cd(3);
TH2D* h_effstepPID1DMConlyyy = (TH2D *) efficiencystepMCPIDall->Project(0,3);
h_effstepPID1DMConlyyy->SetTitle("");
h_effstepPID1DMConlyyy->SetStats(0);
h_effstepPID1DMConlyyy->SetLineColor(kBlue);
h_effstepPID1DMConlyyy->SetMarkerColor(kBlue);
h_effstepPID1DMConlyyy->SetMarkerStyle(25);
gPad->SetLogz();
h_effstepPID1DMConlyyy->Draw("colz");
//////////
// all
//////////
TCanvas * canvasall = new TCanvas("AllMC","AllMC",1000,700);
//canvasall->Divide(2,1);
canvasall->cd(1);
TH2D* h_effstepPID1Dall = (TH2D *) efficiencystepMCall->Project(0,3);
h_effstepPID1Dall->SetTitle("");
h_effstepPID1Dall->SetStats(0);
h_effstepPID1Dall->SetLineColor(kBlue);
h_effstepPID1Dall->SetMarkerColor(kBlue);
h_effstepPID1Dall->SetMarkerStyle(25);
gPad->SetLogz();
h_effstepPID1Dall->Draw("colz");
}
StringValueList* ResultLog::GetColumn(wxString resultname, wxString &name)
{
Result *r = GetResults( resultname );
return r->GetColumn( name );
}
UINT_PTR CALLBACK AddSrcDlgProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
WORD cmd;
int item;
LRESULT rc;
HWND ctl;
lparam = lparam;
switch( msg ) {
case WM_INITDIALOG:
{
OPENFILENAME *of;
ctl = GetDlgItem( hwnd, FOD_REMOVE );
EnableWindow( ctl, FALSE );
ctl = GetDlgItem( hwnd, IDOK );
EnableWindow( ctl, FALSE );
of = (OPENFILENAME *)lparam;
SET_DLGDATA( hwnd, of->lCustData );
initFileList( hwnd );
}
break;
case WM_COMMAND:
cmd = LOWORD( wparam );
switch( cmd ) {
case FOD_FILES:
if( GET_WM_COMMAND_CMD( wparam, lparam ) == LBN_DBLCLK ) {
addCurrentFile( hwnd );
return( TRUE );
} else {
return( FALSE );
}
case IDOK:
return( FALSE );
case FOD_ADD:
addCurrentFile( hwnd );
PostMessage( hwnd, WM_COMMAND, IDOK, 0 );
return( TRUE );
case FOD_ADDALL:
addAllFiles( hwnd );
break;
case FOD_REMOVE:
ctl = GetDlgItem( hwnd, FOD_FILELIST );
item = (int)SendMessage( ctl, LB_GETCURSEL, 0, 0 );
if( item != LB_ERR ) {
rc = SendMessage( ctl, LB_DELETESTRING, item, 0 );
if( item != 0 ) {
SendMessage( ctl, LB_SETCURSEL, item - 1, 0 );
} else {
SendMessage( ctl, LB_SETCURSEL, item, 0 );
}
}
checkRemoveButton( hwnd );
break;
case FOD_FILELIST:
if( GET_WM_COMMAND_CMD( wparam, lparam ) == LBN_SELCHANGE ||
GET_WM_COMMAND_CMD( wparam, lparam ) == LBN_SELCANCEL ) {
checkRemoveButton( hwnd );
}
break;
case FOD_CLOSE:
GetResults( hwnd );
doClose( hwnd );
PostMessage( hwnd, WM_COMMAND, IDOK, 0 );
return( TRUE );
default:
return( FALSE );
}
break;
default:
return( FALSE );
}
return( TRUE );
}
