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;
}
