void CXTPShellTreeView::OnInitialUpdate() { CTreeView::OnInitialUpdate(); // mimic native Windows Explorer styles. DWORD dwStyle = TVS_SHOWSELALWAYS | TVS_HASBUTTONS; if (XTPSystemVersion()->IsWinXPOrGreater()) { dwStyle |= (TVS_TRACKSELECT); } else { dwStyle |= (TVS_HASLINES | TVS_LINESATROOT); } if (InitializeTree(dwStyle)) { PopulateTreeView(); } // make the parent of the selected item visible if found. HTREEITEM hItem = GetTreeCtrl().GetSelectedItem(); HTREEITEM hItemParent = GetTreeCtrl().GetParentItem(hItem); GetTreeCtrl().EnsureVisible(hItemParent ? hItemParent : hItem); }
LRESULT ShellBrowserChild::Init() { CONTEXT("ShellBrowserChild::Init()"); ClientRect rect(_hwnd); const String& root_name = GetDesktopFolder().get_name(_create_info._root_shell_path, SHGDN_FORADDRESSBAR); _root._drive_type = DRIVE_UNKNOWN; lstrcpy(_root._volname, root_name); _root._fs_flags = 0; lstrcpy(_root._fs, TEXT("Desktop")); _root._entry = new ShellDirectory(GetDesktopFolder(), _create_info._root_shell_path, _hwnd); // -> set_curdir() _root._entry->read_directory(); if (_left_hwnd) { InitializeTree(); InitDragDrop(); } jump_to(_create_info._shell_path); return 0; }
int main(void) { Tree pets; char choice; InitializeTree(&pets); while ((choice = menu()) != 'q') { switch (choice) { case 'a' : addpet(&pets); break; case 'l' : showpets(&pets); break; case 'f' : findpet(&pets); break; case 'n' : printf("%d pets in club\n", TreeItemCount(&pets)); break; case 'd' : droppet(&pets); break; default : puts("Switching error"); } } DeleteAll(&pets); puts("Bye."); return 0; }
bool CXTPShellTreeCtrl::Init() { if (!CXTPShellTreeCtrlBase::Init()) return false; if (m_bAutoInit) { // mimic native Windows Explorer styles. DWORD dwStyle = TVS_SHOWSELALWAYS | TVS_HASBUTTONS; if (XTPSystemVersion()->IsWinXPOrGreater()) { dwStyle |= (TVS_TRACKSELECT); } else { dwStyle |= (TVS_HASLINES | TVS_LINESATROOT); } if (InitializeTree(dwStyle)) { PopulateTreeView(); } // make the parent of the selected item visible if found. HTREEITEM hItem = GetSelectedItem(); HTREEITEM hItemParent = GetParentItem(hItem); EnsureVisible(hItemParent ? hItemParent : hItem); } return true; }
void ShellBrowser::Init() { CONTEXT("ShellBrowser::Init()"); const String& root_name = GetDesktopFolder().get_name(_create_info._root_shell_path, SHGDN_FORADDRESSBAR); _root._drive_type = DRIVE_UNKNOWN; lstrcpy(_root._volname, root_name); _root._fs_flags = 0; lstrcpy(_root._fs, TEXT("Desktop")); _root._entry = new ShellDirectory(GetDesktopFolder(), _create_info._root_shell_path, _hwnd); _root._entry->read_directory(SCAN_DONT_ACCESS|SCAN_NO_FILESYSTEM); // avoid to handle desktop root folder as file system directory if (_left_hwnd) { InitializeTree(); InitDragDrop(); } jump_to(_create_info._shell_path); /* already filled by ShellDirectory constructor lstrcpy(_root._entry->_data.cFileName, TEXT("Desktop")); */ }
void *HuffmanCoDec::Decompress( const void *pCompressedBuffer, int iCompressedBufSize, void *pUncompressedBuf, int *piUncompressedBufSize, FNCOMPSTAT fnStat, DWORD dwData ) { ASSERT( pCompressedBuffer ); ASSERT( 0 < iCompressedBufSize ); ASSERT( piUncompressedBufSize ); bitBuffer.AttachForReading( pCompressedBuffer, iCompressedBufSize ); *piUncompressedBufSize = ( int )bitBuffer.GetBits( 32 ); if ( pUncompressedBuf == NULL ) pUncompressedBuf = malloc ( *piUncompressedBufSize ); if ( pUncompressedBuf == NULL ) throw( "Not enough memory" ); BYTE *pBufPos = ( BYTE * )pUncompressedBuf; InitializeTree(); for( ;; ) { int nextSymbol = DecodeSymbol(); if ( nextSymbol == iEND_OF_STREAM ) break; *pBufPos++ = ( BYTE )nextSymbol; UpdateModel( nextSymbol ); } return pUncompressedBuf; }
int main(int argc, char ** argv) { Tree pets; char choice; InitializeTree(&pets); while ((choice = menu()) != 'q') { switch (choice) { case 'a': addPet(&pets); //添加一个宠物 break; case 'l': showPets(&pets); //输出所有宠物的信息 break; case 'f': findPet(&pets); //查找宠物 break; case 'n': printf("%d pets in club\n", //计算宠物的个数 TreeItemCount(&pets)); break; case 'd': dropPet(&pets); //删除某个宠物 break; default: fputs("Switching error\n", stdout); break; } } DeleteAll(&pets); fputs("Bye!\n", stdout); _CrtDumpMemoryLeaks(); return EXIT_SUCCESS; }
int main(void) { Tree pets; char choice; InitializeTree(&pets); while ((choice = menu()) != 'q') { puts(""); if (choice == 'a') { addpet(&pets); } else if (choice == 'l') { showpets(&pets); } else if (choice == 'f') { findpet(&pets); } else if (choice == 'n') { printf("%d pets in club\n", TreeItemCount(pets)); } else if (choice == 'd') { droppet(&pets); } else { printf("Not a valid option.\n"); } puts(""); } DeleteAll(&pets); puts("Bye."); return 0; }
int32 SceneGameObjectManager::OnInitialize() { GTTreeNode* pGlobalConfig = ConfigManager::GetInstance()->GetGlobalConfig(); if(pGlobalConfig) { GTTreeNode* pRootNode = pGlobalConfig->FindChild(CTEXT("SceneGameObjectTree")); if(pRootNode) { // Setup root game object m_pRootGameObject = new GTGameObject(NULL); if(m_pRootGameObject) { m_pRootGameObject->OnInitialize(); // Setup the name m_pRootGameObject->SetName(pRootNode->Value().ToCharString()); // Setup the parent m_pRootGameObject->SetParent(NULL); // Initialize behaviour classes GTTreeNode *pBehaviour = pRootNode->GetChild(PropertyFile::TagBehaviour); if(pBehaviour) { PropertyFile::ApplyBehaviourForGameObject(pBehaviour, m_pRootGameObject, NULL); } // Initialize the children const int32 nChildCount = pRootNode->GetChildCount(); for(int32 i=0; i<nChildCount; i++) { GTTreeNode *pChild = pRootNode->GetChild(i); if(pChild->GetTag() == PropertyFile::TagBehaviour) { // Skip behaviour section continue; } InitializeTree(pChild, m_pRootGameObject); } } DBG_ASSERT(m_pRootGameObject); } } return 1; }
// Initialization int32 SceneGameObjectManager::InitializeTree(GTTreeNode *pTreeNode, GTGameObject *pParent) { if(NULL == pTreeNode) { return 0; } GTGameObject *pGameObjectNode = new GTGameObject(pParent); if(NULL == pGameObjectNode) { return 0; } pGameObjectNode->OnInitialize(); // Setup name pGameObjectNode->SetName(pTreeNode->Tag().ToCharString()); // Setup parent pGameObjectNode->SetParent(pParent); pParent->AddChild(pGameObjectNode); // Initialize behaviour classes GTTreeNode *pBehaviour = pTreeNode->GetChild(PropertyFile::TagBehaviour); if(pBehaviour) { PropertyFile::ApplyBehaviourForGameObject(pBehaviour, pGameObjectNode, NULL); } // Initialize the children const int32 nChildCount = pTreeNode->GetChildCount(); for(int32 i=0; i<nChildCount; i++) { GTTreeNode *pChild = pTreeNode->GetChild(i); if(pChild->GetTag() == PropertyFile::TagBehaviour) { // Skip behaviour section continue; } InitializeTree(pChild, pGameObjectNode); } return 1; }
void *HuffmanCoDec::Compress( const void *pUncompressedBuffer, int iUncompressedBufSize, void * pCompressedBuffer, int *piCompressedBufSize, FNCOMPSTAT fnStat, DWORD dwData ) { ASSERT( pUncompressedBuffer ); ASSERT( 0 < iUncompressedBufSize ); ASSERT( piCompressedBufSize ); // We want to use this as a BYTE array, not a void *. BYTE *pUncompBuf = ( BYTE * )pUncompressedBuffer; *piCompressedBufSize = 3 * iUncompressedBufSize / 2; if ( pCompressedBuffer == NULL ) pCompressedBuffer = malloc ( 1 + *piCompressedBufSize ); if ( pCompressedBuffer == NULL ) throw( "Not enough memory" ); bitBuffer.AttachForWriting( ((char *)pCompressedBuffer) + 1, *piCompressedBufSize ); bitBuffer.PutBits( ( DWORD )iUncompressedBufSize, 32 ); InitializeTree(); while( iUncompressedBufSize ) { BYTE nextSymbol = *pUncompBuf++; iUncompressedBufSize--; EncodeSymbol( nextSymbol ); UpdateModel( nextSymbol ); } EncodeSymbol( iEND_OF_STREAM ); bitBuffer.Flush(); *piCompressedBufSize = bitBuffer.GetSizeInBytes() + 1; * ((char *) pCompressedBuffer) = (char) CODEC::HUFFMAN; pCompressedBuffer = (BYTE *) realloc ( pCompressedBuffer, bitBuffer.GetSizeInBytes() + 1 ); return pCompressedBuffer; }
void main(int argc, char *argv[]) { InitializeTree(); printf("- 2-3 Tree Algorithm\n\n"); InsertNode(10); InsertNode(30); Level_Traverse(head->left); printf("\n====================================\n"); InsertNode(25); InsertNode(7); Level_Traverse(head->left); printf("\n====================================\n"); InsertNode(15); Level_Traverse(head->left); printf("\n====================================\n"); InsertNode(5); InsertNode(23); Level_Traverse(head->left); printf("\n====================================\n"); }
// matlab entry point void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // Currently, we do not have any input or output if (nrhs != 0) mexErrMsgTxt("Wrong number of inputs"); if (nlhs != 0) mexErrMsgTxt("Wrong number of outputs"); // set the seed for random numbers srand(time(NULL)); // set parameters for learning PARAMETER param; SetParameters(param); // get image feature descriptors from the file vector<vector<SINGLEIM>> set_imVec; int classNum; ifstream fi("view_list.txt"); char ind[80]; while(fi >> ind ) { char name[80] = "trainval_0_"; strcat(name, ind); strcat(name,".txt"); mexPrintf("%s", name); vector<SINGLEIM> imVec; GetData(imVec, name, param); set_imVec.push_back(imVec); } // GetData(imVec, "trainval_0_flipped.txt", param); AdjustLabels(set_imVec, classNum); mexPrintf("Finish getting data from the disk.\n"); // pre-pooling for the background information, if it is necessary // if (param.bgPrePooling == 1) // BgPrePooling(imVec, param); // mexPrintf("Finish getting background feature.\n"); // the pre-allocated memory for all the trees int treeMemSize = int(pow(2, param.maxTreeDepth + 1)) * param.treeNum; TREENODE *treeMemory = new TREENODE[treeMemSize]; InitTreeMem(treeMemory, treeMemSize); int treeMemID = 0; vector<TREENODE*> trees; // the set of decision trees for (int i = 0; i < param.treeNum; i++) { trees.push_back(treeMemory + treeMemID); treeMemID++; } mexPrintf("Finish initializing all the trees.\n"); // train decision trees clock_t t1, t2; vector<int> trainID, valID; // indicate which samples are included in the current tree node char filename[1024]; float *valDist = (float*)malloc(sizeof(float) * classNum); // sample distribution in the val set for (int i = 0; i < param.treeNum; i++) { t1 = clock(); GetFilename(filename); mexPrintf("\nThe current tree will be in this file: %s\n", filename); trainID.clear(); valID.clear(); InitializeTree(trees[i]); int nodeID = 0; memset(valDist, 0, sizeof(float) * classNum); TrainDecisionTree(trees[i], set_imVec, param, trainID, valID, classNum, nodeID, treeMemory, treeMemID, valDist); // sprintf(filename, "trees/tree_%d%d%d.txt", i / 100, (i % 100) / 10, i % 10); OutputTree(trees[i], filename); t2 = clock(); mexPrintf("\n Time for trainning this tree: %f\n", (float)(t2 - t1) / CLOCKS_PER_SEC); } free(valDist); for(int i = 0 ; i < set_imVec.size(); i++) { ReleaseData(set_imVec.at(i)); } for (int i = 0; i < param.treeNum; i++) ReleaseTreeMem(trees[i]); delete[] treeMemory; }
int main(int argc, char** argv) { //Check if all nedeed arguments to parse are there if(argc != 2) { std::cerr << ">>>>> analysis.cpp::usage: " << argv[0] << " configFileName" << std::endl ; return 1; } // Parse the config file parseConfigFile (argv[1]) ; std::string treeName = gConfigParser -> readStringOption("Input::treeName"); std::string inputFile = gConfigParser -> readStringOption("Input::inputFile"); double inputXSection = gConfigParser -> readDoubleOption("Input::inputXSection"); int entryMAX = gConfigParser -> readIntOption("Input::entryMAX"); int entryMIN = gConfigParser -> readIntOption("Input::entryMIN"); int entryMOD = gConfigParser -> readIntOption("Input::entryMOD"); std::cout << ">>>>> input::entryMIN " << entryMIN << std::endl; std::cout << ">>>>> input::entryMAX " << entryMAX << std::endl; std::cout << ">>>>> input::entryMOD " << entryMOD << std::endl; int dataFlag = 0; if (inputXSection == -1) dataFlag = 1; //==== it's a data sample!!! std::cerr << ">>>>> input:: --- dataFlag " << dataFlag << std::endl; // define map with events std::map<std::pair<int,std::pair<int,int> >,int> eventsMap; int nStepToDo = 1000; try { nStepToDo = gConfigParser -> readIntOption("Input::nStepToDo"); } catch (char const* exceptionString){ std::cerr << " exception = " << exceptionString << std::endl; nStepToDo = 1000; } std::cout << ">>>>> input::nStepToDo " << nStepToDo << std::endl; // Open ntple TChain* chain = new TChain(treeName.c_str()); chain->Add(inputFile.c_str()); treeReader reader((TTree*)(chain)); bool debug = false; try { debug = gConfigParser -> readBoolOption("Input::debug"); } catch (char const* exceptionString){ std::cerr << " exception = " << exceptionString << std::endl; } std::cout << ">>>>> input::debug " << debug << std::endl; ///****************** ///**** Triggers **** std::vector<std::string> HLTVector; try { HLTVector = gConfigParser -> readStringListOption("Options::HLTVector"); } catch (char const* exceptionString){ std::cerr << " exception = " << exceptionString << std::endl; } std::cout << ">>>>> Options::HLTVector size = " << HLTVector.size() << std::endl; std::cout << ">>>>> >>>>> "; for (int iHLT = 0; iHLT < HLTVector.size(); iHLT++){ std::cout << " " << HLTVector.at(iHLT) << ", "; } std::cout << std::endl; ///**************************** ///**** DATA JSON file **** std::string inFileNameJSON; try { inFileNameJSON = gConfigParser -> readStringOption("Input::inFileNameJSON"); } catch (char const* exceptionString){ std::cerr << " exception = " << exceptionString << std::endl; } std::cout << ">>>>> Input::inFileNameJSON " << inFileNameJSON << std::endl; std::map<int, std::vector<std::pair<int, int> > > jsonMap; if( dataFlag == 1 ) { jsonMap = readJSONFile(inFileNameJSON); } ///---- Efficiency preselections ---- std::string histoNameEvents = gConfigParser -> readStringOption("Input::histoNameEvents"); std::cout << ">>>>> Input::inputFile " << inputFile << std::endl; std::cout << ">>>>> Input::inputXSection " << inputXSection << std::endl; std::cout << ">>>>> Input::histoNameEvents " << histoNameEvents << std::endl; // Open ntples TFile File(inputFile.c_str()) ; TH1F* histoEvents = (TH1F*) File.Get(TString(histoNameEvents.c_str())); ///---------------------- ///---- Preselection ---- ///~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///==== only retrocompatibility ==== ///================================= double lepton_efficiency = 1; double jet_efficiency = 1; double eff_Channel_Filter = 1; double preselection_efficiency = 1.; ///~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///------------------- ///---- selection ---- std::string outFileName = gConfigParser -> readStringOption("Output::outFileName"); std::cout << ">>>>> Output::outFileName " << outFileName << std::endl; int nStep = 10; ///==== number of steps in the analysis int numEntriesBefore; // define variable container Variables vars; InitializeTree(vars, outFileName); InitializeTreeTrigger(vars, HLTVector, reader); vars.XSection = inputXSection; vars.dataFlag = dataFlag; ///~~~~ 0 = MC 1 = DATA if (entryMAX == -1) entryMAX = reader.GetEntries(); else if (reader.GetEntries() < entryMAX) entryMAX = reader.GetEntries(); numEntriesBefore = entryMAX - entryMIN; if (histoEvents) preselection_efficiency = numEntriesBefore / (1. * histoEvents->GetBinContent(1)); else preselection_efficiency = 1; vars.numEntriesBefore = numEntriesBefore; vars.preselection_efficiency = preselection_efficiency; FillEfficiencyTree(vars); ///************************************* ///**** definition of electron ID **** ///**** https://twiki.cern.ch/twiki/bin/viewauth/CMS/SimpleCutBasedEleID ///**** https://twiki.cern.ch/twiki/bin/viewauth/CMS/SimpleCutBasedEleID2011 std::vector<double> BarrelSelections; std::vector<double> EndcapSelections; double eleCombinedIsoBarrel = gConfigParser -> readDoubleOption("Selection::eleCombinedIsoBarrel"); double elesigmaIetaIetaBarrel = gConfigParser -> readDoubleOption("Selection::elesigmaIetaIetaBarrel"); double eledPhiBarrel = gConfigParser -> readDoubleOption("Selection::eledPhiBarrel"); double eledEtaBarrel = gConfigParser -> readDoubleOption("Selection::eledEtaBarrel"); double eleCombinedIsoEndcap = gConfigParser -> readDoubleOption("Selection::eleCombinedIsoEndcap"); double elesigmaIetaIetaEndcap = gConfigParser -> readDoubleOption("Selection::elesigmaIetaIetaEndcap"); double eledPhiEndcap = gConfigParser -> readDoubleOption("Selection::eledPhiEndcap"); double eledEtaEndcap = gConfigParser -> readDoubleOption("Selection::eledEtaEndcap"); double elemishits = gConfigParser -> readDoubleOption("Selection::elemishits"); double eledist = gConfigParser -> readDoubleOption("Selection::eledist"); double eledcot = gConfigParser -> readDoubleOption("Selection::eledcot"); double eledzPV = gConfigParser -> readDoubleOption("Selection::eledzPV"); double eledxyPV = gConfigParser -> readDoubleOption("Selection::eledxyPV"); BarrelSelections.push_back(eleCombinedIsoBarrel); BarrelSelections.push_back(elesigmaIetaIetaBarrel); BarrelSelections.push_back(eledPhiBarrel); BarrelSelections.push_back(eledEtaBarrel); BarrelSelections.push_back(elemishits); BarrelSelections.push_back(eledist); BarrelSelections.push_back(eledcot); BarrelSelections.push_back(eledzPV); BarrelSelections.push_back(eledxyPV); EndcapSelections.push_back(eleCombinedIsoEndcap); EndcapSelections.push_back(elesigmaIetaIetaEndcap); EndcapSelections.push_back(eledPhiEndcap); EndcapSelections.push_back(eledEtaEndcap); EndcapSelections.push_back(elemishits); EndcapSelections.push_back(eledist); EndcapSelections.push_back(eledcot); EndcapSelections.push_back(eledzPV); EndcapSelections.push_back(eledxyPV); ///**** https://twiki.cern.ch/twiki/bin/viewauth/CMS/SimpleCutBasedEleID --> 2010 Data ///**** 95% **** /* BarrelSelections.push_back(0.15); ///==== iso Tk BarrelSelections.push_back(2.00); ///==== iso em BarrelSelections.push_back(0.12); ///==== iso had BarrelSelections.push_back(0.15); ///==== iso combined BarrelSelections.push_back(0.015); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.8); ///==== dPhi BarrelSelections.push_back(0.007); ///==== dEta EndCapSelections.push_back(0.08); ///==== iso Tk EndCapSelections.push_back(0.06); ///==== iso em EndCapSelections.push_back(0.05); ///==== iso had EndCapSelections.push_back(0.10); ///==== iso combined EndCapSelections.push_back(0.07); ///==== hOe EndCapSelections.push_back(0.03); ///==== sigmaIetaIeta EndCapSelections.push_back(0.7); ///==== dPhi EndCapSelections.push_back(0.01); ///==== dEta */ ///**** 90% **** /* BarrelSelections.push_back(0.12); ///==== iso Tk BarrelSelections.push_back(0.09); ///==== iso em BarrelSelections.push_back(0.10); ///==== iso had BarrelSelections.push_back(0.10); ///==== iso combined BarrelSelections.push_back(0.12); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.8); ///==== dPhi BarrelSelections.push_back(0.007); ///==== dEta EndCapSelections.push_back(0.05); ///==== iso Tk EndCapSelections.push_back(0.06); ///==== iso em EndCapSelections.push_back(0.03); ///==== iso had EndCapSelections.push_back(0.07); ///==== iso combined EndCapSelections.push_back(0.05); ///==== hOe EndCapSelections.push_back(0.03); ///==== sigmaIetaIeta EndCapSelections.push_back(0.7); ///==== dPhi EndCapSelections.push_back(0.007); ///==== dEta */ ///**** 80% **** /* BarrelSelections.push_back(0.09); ///==== iso Tk BarrelSelections.push_back(0.07); ///==== iso em BarrelSelections.push_back(0.10); ///==== iso had BarrelSelections.push_back(0.07); ///==== iso combined BarrelSelections.push_back(0.040); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.06); ///==== dPhi BarrelSelections.push_back(0.004); ///==== dEta EndCapSelections.push_back(0.04); ///==== iso Tk EndCapSelections.push_back(0.05); ///==== iso em EndCapSelections.push_back(0.025); ///==== iso had EndCapSelections.push_back(0.06); ///==== iso combined EndCapSelections.push_back(0.025); ///==== hOe EndCapSelections.push_back(0.03); ///==== sigmaIetaIeta EndCapSelections.push_back(0.03); ///==== dPhi EndCapSelections.push_back(0.007); ///==== dEta */ ///**** 70% **** /* BarrelSelections.push_back(0.05); ///==== iso Tk BarrelSelections.push_back(0.06); ///==== iso em BarrelSelections.push_back(0.03); ///==== iso had BarrelSelections.push_back(0.04); ///==== iso combined BarrelSelections.push_back(0.025); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.004); ///==== dPhi BarrelSelections.push_back(0.004); ///==== dEta EndCapSelections.push_back(0.025); ///==== iso Tk EndCapSelections.push_back(0.025); ///==== iso em EndCapSelections.push_back(0.02); ///==== iso had EndCapSelections.push_back(0.03); ///==== iso combined EndCapSelections.push_back(0.025); ///==== hOe EndCapSelections.push_back(0.03); ///==== sigmaIetaIeta EndCapSelections.push_back(0.02); ///==== dPhi EndCapSelections.push_back(0.005); ///==== dEta */ ///**** https://twiki.cern.ch/twiki/bin/viewauth/CMS/SimpleCutBasedEleID2011 --> 2011 Data ///**** 95% **** /* BarrelSelections.push_back(10000.); ///==== iso Tk BarrelSelections.push_back(10000.); ///==== iso em BarrelSelections.push_back(10000.); ///==== iso had BarrelSelections.push_back(0.150); ///==== iso combined BarrelSelections.push_back(10000.); ///==== hOe BarrelSelections.push_back(0.012); ///==== sigmaIetaIeta BarrelSelections.push_back(0.800); ///==== dPhi BarrelSelections.push_back(0.007); ///==== dEta EndCapSelections.push_back(10000.); ///==== iso Tk EndCapSelections.push_back(10000.); ///==== iso em EndCapSelections.push_back(10000.); ///==== iso had EndCapSelections.push_back(0.100); ///==== iso combined EndCapSelections.push_back(10000.); ///==== hOe EndCapSelections.push_back(0.031); ///==== sigmaIetaIeta EndCapSelections.push_back(0.7); ///==== dPhi EndCapSelections.push_back(0.011); ///==== dEta */ ///**** 90% **** /* BarrelSelections.push_back(10000.); ///==== iso Tk BarrelSelections.push_back(10000.); ///==== iso em BarrelSelections.push_back(10000.); ///==== iso had BarrelSelections.push_back(0.085); ///==== iso combined BarrelSelections.push_back(10000.); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.071); ///==== dPhi BarrelSelections.push_back(0.007); ///==== dEta EndCapSelections.push_back(10000.); ///==== iso Tk EndCapSelections.push_back(10000.); ///==== iso em EndCapSelections.push_back(10000.); ///==== iso had EndCapSelections.push_back(0.051); ///==== iso combined EndCapSelections.push_back(10000.); ///==== hOe EndCapSelections.push_back(0.031); ///==== sigmaIetaIeta EndCapSelections.push_back(0.047); ///==== dPhi EndCapSelections.push_back(0.011); ///==== dEta */ ///**** 85% **** /* BarrelSelections.push_back(10000.); ///==== iso Tk BarrelSelections.push_back(10000.); ///==== iso em BarrelSelections.push_back(10000.); ///==== iso had BarrelSelections.push_back(0.053); ///==== iso combined BarrelSelections.push_back(10000.); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.039); ///==== dPhi BarrelSelections.push_back(0.005); ///==== dEta EndCapSelections.push_back(10000.); ///==== iso Tk EndCapSelections.push_back(10000.); ///==== iso em EndCapSelections.push_back(10000.); ///==== iso had EndCapSelections.push_back(0.042); ///==== iso combined EndCapSelections.push_back(10000.); ///==== hOe EndCapSelections.push_back(0.031); ///==== sigmaIetaIeta EndCapSelections.push_back(0.028); ///==== dPhi EndCapSelections.push_back(0.007); ///==== dEta */ ///**** 80% **** /* BarrelSelections.push_back(10000.); ///==== iso Tk BarrelSelections.push_back(10000.); ///==== iso em BarrelSelections.push_back(10000.); ///==== iso had BarrelSelections.push_back(0.040); ///==== iso combined BarrelSelections.push_back(10000.); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.027); ///==== dPhi BarrelSelections.push_back(0.005); ///==== dEta EndCapSelections.push_back(10000.); ///==== iso Tk EndCapSelections.push_back(10000.); ///==== iso em EndCapSelections.push_back(10000.); ///==== iso had EndCapSelections.push_back(0.033); ///==== iso combined EndCapSelections.push_back(10000.); ///==== hOe EndCapSelections.push_back(0.031); ///==== sigmaIetaIeta EndCapSelections.push_back(0.021); ///==== dPhi EndCapSelections.push_back(0.006); ///==== dEta */ ///*********************************** ///**** definition of muon ID **** std::vector<double> Selections; double muCombinedIso = gConfigParser -> readDoubleOption("Selection::muCombinedIso"); double muChi2Ndof = gConfigParser -> readDoubleOption("Selection::muChi2Ndof"); double muValidTrackerHits = gConfigParser -> readDoubleOption("Selection::muValidTrackerHits"); double muValidMuonHits = gConfigParser -> readDoubleOption("Selection::muValidMuonHits"); double mutracker = gConfigParser -> readDoubleOption("Selection::mutracker"); double mustandalone = gConfigParser -> readDoubleOption("Selection::mustandalone"); double muglobal = gConfigParser -> readDoubleOption("Selection::muglobal"); double mudzPV = gConfigParser -> readDoubleOption("Selection::mudzPV"); double mudxyPV = gConfigParser -> readDoubleOption("Selection::mudxyPV"); Selections.push_back(muCombinedIso); Selections.push_back(muChi2Ndof); Selections.push_back(muValidTrackerHits); Selections.push_back(muValidMuonHits); Selections.push_back(mutracker); Selections.push_back(mustandalone); Selections.push_back(muglobal); Selections.push_back(mudzPV); Selections.push_back(mudxyPV); /* Selections.push_back(0.15); ///==== iso Combined Selections.push_back(10); ///==== Chi2/ndof Selections.push_back(10); ///==== n ValidTrackerHits Selections.push_back(0); ///==== n ValidMuonHits Selections.push_back(1); ///==== tracker Selections.push_back(1); ///==== standalone Selections.push_back(1); ///==== global //Selections.push_back(1); ///==== goodMuon */ double start, end; std::cout << ">>>>> analysis::entryMIN " << entryMIN << " ==> entryMAX " << entryMAX << ":" << reader.GetEntries() << std::endl; int step = 0; start = clock(); for(int iEvent = entryMIN ; iEvent < entryMAX ; ++iEvent) { reader.GetEntry(iEvent); if((iEvent%entryMOD) == 0) std::cout << ">>>>> analysis::GetEntry " << iEvent << " : " << entryMAX - entryMIN << std::endl; ///==== define variables ==== std::vector<ROOT::Math::XYZTVector>* jets = reader.Get4V("jets"); // std::vector<ROOT::Math::XYZTVector>* muons = reader.Get4V("muons"); // std::vector<ROOT::Math::XYZTVector>* electrons = reader.Get4V("electrons"); ///********************************************************************************************* ///********************************************************************************************* ///============================= ///==== fill MC information ==== SetMCVariables(vars, reader); ///============================= ///==== fill Primary Vertex ==== SetPVVariables(vars, reader); ///================================ ///==== fill Event information ==== SetEventVariables(vars, reader); ///*************************************************** ///**** STEP -1 - Check no copies in DATA **** ///*************************************************** if (debug) std::cout << " STEP -1 " << std::endl; if( dataFlag == 1 ) { std::pair<int,int> eventLSandID(reader.GetInt("lumiId")->at(0), reader.GetInt("eventId")->at(0)); std::pair<int,std::pair<int,int> > eventRUNandLSandID(reader.GetInt("runId")->at(0), eventLSandID); if( eventsMap[eventRUNandLSandID] == 1 ) continue; else eventsMap[eventRUNandLSandID] = 1; } ///************************************************* ///**** Check comparison with JSON file *** ///************************************************* if( dataFlag == 1 ) { int runId = reader.GetInt("runId")->at(0); int lumiId = reader.GetInt("lumiId")->at(0); if(AcceptEventByRunAndLumiSection(runId, lumiId, jsonMap) == false) continue; } ///**************************** ///**** STEP 0 - Ntuplizer **** ///************* no additional selections applied step = 0; if (step > nStepToDo) { FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 0 <<<" << std::endl; ///********************************************* ///**** STEP 1 - Jet cleaning + min pT **** ///************* it's performed another time here to make sure that the cleaning worked well ///************* Jet - electrons (pT > 5) ///************* Jet - muons (pT > 5) ///************ In addition only jets with pT > 15 are considered from now on! ///************ No selections are applied here step = 1; if (step > nStepToDo) { // FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 1 <<<" << std::endl; std::vector<ROOT::Math::XYZTVector> leptons_jetCleaning; // build the collection of electros for jet cleaning ///==== CLEANING WITH ELECTRONS ==== for(unsigned int iEle = 0; iEle < (reader.Get4V("electrons")->size()); ++iEle) { if( reader.Get4V("electrons")->at(iEle).pt() < 5. ) continue; // bool flag = IsEleIsolatedID_VBF(reader,BarrelSelections,EndcapSelections,iEle); bool flag = IsEleIsolatedIDPUCorrected_VBF(reader,BarrelSelections,EndcapSelections,iEle); if (!flag) continue; leptons_jetCleaning.push_back( reader.Get4V("electrons")->at(iEle) ); } ///==== CLEANING WITH MUONS ==== for (int iMu = 0; iMu < reader.Get4V("muons")->size(); iMu++){ if (reader.Get4V("muons")->at(iMu).pt() < 5.0) continue; if (fabs(reader.Get4V("muons")->at(iMu).Eta()) > 2.5) continue; // bool flag = IsMuIsolatedID_VBF(reader,Selections,iMu); bool flag = IsMuIsolatedIDPUCorrected_VBF(reader,Selections,iMu); if (!flag) continue; leptons_jetCleaning.push_back( reader.Get4V("muons")->at(iMu) ); } ///==== now clean jet collection ==== int nJets = reader.Get4V("jets")->size(); std::vector<int> whitelistJet; ///~~~~ all jets, 0 if rejected, 1 if accepted std::vector<int> blacklistJet; ///~~~~ list of numbers of jets that are "rejected" std::vector<int> blacklistJet_forCJV; std::vector<int> blacklistJet_forBtag; for (int iJet = 0; iJet < nJets; iJet++){ bool skipJet = false; if (reader.Get4V("jets")->at(iJet).Et() < 15.0) skipJet = true; for(unsigned int iLep = 0; iLep < leptons_jetCleaning.size(); ++iLep) { ROOT::Math::XYZTVector lep = leptons_jetCleaning.at(iLep); if (ROOT::Math::VectorUtil::DeltaR(reader.Get4V("jets")->at(iJet),lep) < 0.3 ) skipJet = true; } if (skipJet) { whitelistJet.push_back(0); ///---- reject blacklistJet.push_back(iJet); ///---- reject ///== black list is in a different format blacklistJet_forCJV.push_back(iJet); ///---- reject ///== black list is in a different format blacklistJet_forBtag.push_back(iJet); ///---- reject ///== black list is in a different format } else { whitelistJet.push_back(1); ///---- select } } ///************************************** ///**** STEP 2 - Super-Preselections **** ///************* tighter preselections to start the analysis from the same point ///==== construct considered objets /// Objects considered and selections /// Muon /// Pt>10GeV, eta<2.5 /// MuonId & Iso /// /// Electron /// Pt>10GeV & |eta|<2.5 /// eleId & Iso /// /// At least two leptons /// Jet /// Antikt5, L2L3 correction jets /// At least two calo jets or two pf jets with pt>15 GeV //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ step = 2; if (step > nStepToDo) { // FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 2 <<<" << std::endl; /// Electron /// Pt>10GeV & |eta|<2.5 /// IsoTr / pTele <0.5 /// eleId & Iso std::vector<int> whitelistEle; std::vector<int> blacklistEle; int nEles = reader.Get4V("electrons")->size(); for (int iEle = 0; iEle < nEles; iEle++){ bool skipEle = false; if (reader.Get4V("electrons")->at(iEle).pt() < 10.0) skipEle = true; if (fabs(reader.Get4V("electrons")->at(iEle).Eta()) > 2.5) skipEle = true; // bool flag = IsEleIsolatedID_VBF(reader,BarrelSelections,EndcapSelections,iEle); bool flag = IsEleIsolatedIDPUCorrected_VBF(reader,BarrelSelections,EndcapSelections,iEle); if (!flag) skipEle = true; if (skipEle) { whitelistEle.push_back(0); ///---- reject blacklistEle.push_back(iEle); ///---- reject ///== black list is in a different format } else { whitelistEle.push_back(1); ///---- select } } /// Muon /// Pt>10GeV, eta<2.5 /// MuonId & Iso std::vector<int> whitelistMu; std::vector<int> blacklistMu; int nMus = reader.Get4V("muons")->size(); for (int iMu = 0; iMu < nMus; iMu++){ bool skipMu = false; if (reader.Get4V("muons")->at(iMu).pt() < 10.0) skipMu = true; if (fabs(reader.Get4V("muons")->at(iMu).Eta()) > 2.5) skipMu = true; // bool flag = IsMuIsolatedID_VBF(reader,Selections,iMu); bool flag = IsMuIsolatedIDPUCorrected_VBF(reader,Selections,iMu); if (!flag) skipMu = true; if (skipMu) { whitelistMu.push_back(0); ///---- reject blacklistMu.push_back(iMu); ///---- reject ///== black list is in a different format } else { whitelistMu.push_back(1); ///---- select } } /// At least 2 leptons int numMus_Accepted = GetNumList(whitelistMu); int numEles_Accepted = GetNumList(whitelistEle); int numLeptons_Accepted = numMus_Accepted + numEles_Accepted; if (numLeptons_Accepted < 2) continue; /// Jet /// At least two calo jets or two pf jets with pt>20 GeV int numJets_Accepted = GetNumList(whitelistJet); if (numJets_Accepted < 2) continue; ///==== at least 2 jets "isolated" ///************************* ///**** STEP 3 - Jet ID **** ///************* Identification of two tag jets step = 3; if (step > nStepToDo) { // FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 3 <<<" << std::endl; std::vector<int> itSelJet; double maxPt_jets_selected = SelectJets(itSelJet,*jets,"maxSumPt",-1.,&blacklistJet); int q1 = itSelJet.at(0); int q2 = itSelJet.at(1); ///---- check Pt order ---- if (jets->at(q1).Pt() < jets->at(q2).Pt()) { int tempq = q1; q1 = q2; q2 = tempq; } if (debug) std::cerr << " q1 = " << q1 << " : q2 = " << q2 << std::endl; ///---- update white/black list jets ---- for (int iJet = 0; iJet < nJets; iJet++){ if (q1 == iJet || q2 == iJet) { whitelistJet.at(iJet) = 1; blacklistJet.push_back(iJet); ///===> blacklistJet used for CJV => no 2 tag jets to be considered! blacklistJet_forCJV.push_back(iJet); ///===> blacklistJet used for CJV => no 2 tag jets to be considered! } else { whitelistJet.at(iJet) = 0; } } SetQJetVariables(vars, reader, q1, q2, blacklistJet_forCJV, blacklistJet_forBtag, blacklistJet_forBtag); ///******************************** ///**** STEP 4 - Lepton ID **** ///************* Identification of the two leptons step = 4; if (step > nStepToDo) { FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 4 <<<" << std::endl; std::vector<ROOT::Math::XYZTVector> leptons; std::vector<int> leptonFlavours; std::vector<int> leptonILep; for(unsigned int iEle = 0; iEle < nEles; iEle++){ if (whitelistEle.at(iEle) == 1){ leptons.push_back( reader.Get4V("electrons")->at(iEle) ); leptonFlavours.push_back(11); leptonILep.push_back(iEle); } } for(unsigned int iMu = 0; iMu < nMus; iMu++){ if (whitelistMu.at(iMu) == 1){ leptons.push_back( reader.Get4V("muons")->at(iMu) ); leptonFlavours.push_back(13); leptonILep.push_back(iMu); } } std::vector<int> itSelLep; double maxPt_lept_selected = SelectJets(itSelLep,leptons,"maxSumPt",-1.,0); int l1 = itSelLep.at(0); int l2 = itSelLep.at(1); ///---- check Pt order ---- if (leptons.at(l1).Pt() < leptons.at(l2).Pt()) { int templ = l1; l1 = l2; l2 = templ; } if (debug) std::cerr << " l1 = " << l1 << " : l2 = " << l2 << std::endl; SetLeptonsVariables(vars, reader, leptonILep.at(l1), leptonILep.at(l2),leptonFlavours.at(l1), leptonFlavours.at(l2)); if (debug) std::cerr << ">> Lepton variables set" << std::endl; SetMetVariables(vars, reader, "PFMet", leptonILep.at(l1), leptonILep.at(l2),leptonFlavours.at(l1), leptonFlavours.at(l2)); if (debug) std::cerr << ">> MET variables set" << std::endl; //---- lepton veto std::vector<int> blacklistLepton; blacklistLepton.push_back(l1); blacklistLepton.push_back(l2); vars.Nleptons_pT5 = getNumberPTThreshold(leptons, 5, &blacklistLepton); vars.Nleptons_pT10 = getNumberPTThreshold(leptons, 10, &blacklistLepton); vars.Nleptons_pT15 = getNumberPTThreshold(leptons, 15, &blacklistLepton); vars.Nleptons_pT20 = getNumberPTThreshold(leptons, 20, &blacklistLepton); vars.Nleptons_pT25 = getNumberPTThreshold(leptons, 25, &blacklistLepton); vars.Nleptons_pT30 = getNumberPTThreshold(leptons, 30, &blacklistLepton); if (debug) std::cerr << ">> Lepton multiplicity set" << std::endl; ///********************************* ///**** STEP 5 - Jet Selections **** ///************* Loose selections of tag jets step = 5; if (step > nStepToDo) { FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 5 <<<" << std::endl; ///---- hardcoded fixed preselections ---- VBF (begin) ---- if (vars.q1_pT < 20.) continue; if (vars.q2_pT < 15.) continue; if (vars.M_qq < 0.) continue; if (vars.DEta_qq < 0.) continue; ///---- hardcoded fixed preselections ---- VBF (end) ---- ///==== save trigger variables ==== SetTriggerVariables(vars, reader); ///************************************ ///**** STEP 6 - Final Production ***** ///************************************ ///**** No more selections applied **** step = 6; if (step > nStepToDo) { FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 6 <<<" << std::endl; ///==== if not already filled ... ==== FillTree(vars); ///================================================= } end = clock(); std::cout <<"Time = " << ((double) (end - start)) << " (a.u.)" << std::endl; SaveTree(vars); std::cerr << " === end === " << std::endl; }
// matlab entry point void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // input must have tree size, binary_feature_filename, binary_feature_flipped_filename, action name if (nrhs != 4) mexErrMsgTxt("Wrong number of inputs, treesize, binaryfeaturefilename, binaryfeatureflippedfilename, action_name needed"); // Currently, we do not have any output if (nlhs != 0) mexErrMsgTxt("Wrong number of outputs"); /* make sure the first input argument is scalar */ if( !mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) || mxGetNumberOfElements(prhs[0])!=1 ) { mexErrMsgIdAndTxt("MyToolbox:arrayProduct:notScalar", "Input tree size must be a scalar."); } /* input must be a string */ if ( mxIsChar(prhs[1]) != 1 || mxIsChar(prhs[2]) != 1 || mxIsChar(prhs[3]) != 1 ) mexErrMsgIdAndTxt( "MATLAB:revord:inputNotString", "Input must be a string."); // read in input string char *DataFilename, *DataFilenameFlipped, *action; DataFilename = mxArrayToString(prhs[1]); DataFilenameFlipped = mxArrayToString(prhs[2]); action = mxArrayToString(prhs[3]); // set the seed for random numbers srand(time(NULL)); mexPrintf("Entered dttrain.cpp!\n"); // debug!!!! // set parameters for learning PARAMETER param; SetParameters(param); param.treeNum = mxGetScalar(prhs[0]); // treat tree num specially mexPrintf("tree num is %d\n", param.treeNum); // debug!!!! mexPrintf("parameters set!\n"); // debug!!!! // get image feature descriptors from the file vector<SINGLEIM> imVec; int classNum; // use filename passed in here!!! GetData(imVec, DataFilename, param); mexPrintf("read %s to image vector! total size of %d\n", DataFilename, imVec.size()); // debug!!!! //GetData(imVec, DataFilenameFlipped, param); //mexPrintf("read %s to image vector, total size of %d\n", DataFilenameFlipped, imVec.size()); // debug!!!! AdjustLabels(imVec, classNum); mexPrintf("Finish getting data from the disk.\n"); // pre-pooling for the background information, if it is necessary // if (param.bgPrePooling == 1) // BgPrePooling(imVec, param); // mexPrintf("Finish getting background feature.\n"); // the pre-allocated memory for all the trees int treeMemSize = int(pow(2, param.maxTreeDepth + 1)) * param.treeNum; TREENODE *treeMemory = new TREENODE[treeMemSize]; InitTreeMem(treeMemory, treeMemSize); int treeMemID = 0; vector<TREENODE*> trees; // the set of decision trees for (int i = 0; i < param.treeNum; i++) { trees.push_back(treeMemory + treeMemID); treeMemID++; } mexPrintf("Finish initializing all the trees.\n"); // train decision trees clock_t t1, t2; vector<int> trainID, valID; // indicate which samples are included in the current tree node char filename[1024]; float *valDist = (float*)malloc(sizeof(float) * classNum); // sample distribution in the val set for (int i = 0; i < param.treeNum; i++) { t1 = clock(); GetFilename(filename, action); mexPrintf("\nThe current tree will be in this file: %s\n", filename); trainID.clear(); valID.clear(); InitializeTree(trees[i]); int nodeID = 0; memset(valDist, 0, sizeof(float) * classNum); TrainDecisionTree(trees[i], imVec, param, trainID, valID, classNum, nodeID, treeMemory, treeMemID, valDist); // sprintf(filename, "trees/tree_%d%d%d.txt", i / 100, (i % 100) / 10, i % 10); OutputTree(trees[i], filename); t2 = clock(); mexPrintf("\n Time for trainning this tree: %f\n", (float)(t2 - t1) / CLOCKS_PER_SEC); } free(valDist); ReleaseData(imVec); for (int i = 0; i < param.treeNum; i++) ReleaseTreeMem(trees[i]); delete[] treeMemory; }