LONG CuDlgIpmPageProcesses::OnLoad (WPARAM wParam, LPARAM lParam)
{
LPCTSTR pClass = (LPCTSTR)wParam;
ASSERT (lstrcmp (pClass, _T("CuIpmPropertyDataPageProcesses")) == 0);
CTypedPtrList<CObList, CuDataTupleProcess*>* pListTuple;
pListTuple = (CTypedPtrList<CObList, CuDataTupleProcess*>*)lParam;
CuDataTupleProcess* pObj = NULL;
POSITION pos = pListTuple->GetHeadPosition();
try
{
ResetDisplay();
while (pos != NULL)
{
pObj = (CuDataTupleProcess*)pListTuple->GetNext (pos);
ASSERT (pObj);
AddProcess (
pObj->m_strID,
pObj->m_strPID,
pObj->m_strType,
pObj->m_strOpenDB,
pObj->m_strWrite,
pObj->m_strForce,
pObj->m_strWait,
pObj->m_strBegin,
pObj->m_strEnd,
NULL);
}
}
catch (CMemoryException* e)
{
theApp.OutOfMemoryMessage();
e->Delete();
}
return 0L;
}
void ProcessManager::UpdateProcesses(float elapsed_time)
{
// Iterate over all processes.
ProcessList::iterator it = processes_.begin();
while (it != processes_.end())
{
StrongProcessPtr process = *it;
// If the process hasn't been initialized yet.
if (process->GetState() == Process::State::UNINITIALIZED)
{
// Initialize it.
process->OnInit();
}
// If the process is running.
if (process->GetState() == Process::State::RUNNING)
{
// Update it.
process->OnUpdate(elapsed_time);
}
// If the process is dead.
if (process->IsDead())
{
// If he exited successfully.
if (process->GetState() == Process::State::SUCCEEDED)
{
// Call the appropriate exit method.
process->OnSuccess();
// Attach the children to the process manager if the process had some.
const std::vector<StrongProcessPtr>& children = process->GetChildren();
if (!children.empty())
for (StrongProcessPtr child : children)
AddProcess(child);
process->ClearChildren();
}
// If he exited with an failure.
else if (process->GetState() == Process::State::FAILED)
{
process->OnFail();
}
// If he was aborted.
else if (process->GetState() == Process::State::ABORTED)
{
process->OnAbort();
}
// Remove the process and set the iterator to the next process.
it = processes_.erase(it);
}
// If the process isn't dead we have to increment the iterator.
else
{
++it;
}
}
}
void TUI_CustomControl::Move (TShiftState _Shift){
switch(action){
case etaSelect: SelectProcess(_Shift); break;
case etaAdd: AddProcess(_Shift); break;
case etaMove: MovingProcess(_Shift); break;
case etaRotate: RotateProcess(_Shift); break;
case etaScale: ScaleProcess(_Shift); break;
}
}
LONG CuDlgIpmPageProcesses::OnUpdateData (WPARAM wParam, LPARAM lParam)
{
BOOL bOK = FALSE;
CPtrList listInfoStruct;
LOGPROCESSDATAMIN* pData;
LPIPMUPDATEPARAMS pUps = (LPIPMUPDATEPARAMS)lParam;
CString strID;
CString strPID;
CString strType;
CString strOpenDB;
CString strWrite;
CString strForce;
CString strWait;
CString strBegin;
CString strEnd;
ASSERT (pUps);
switch (pUps->nIpmHint)
{
case 0:
break;
default:
return 0L;
}
try
{
LOGPROCESSDATAMIN structData;
CdIpmDoc* pDoc = (CdIpmDoc*)wParam;
ResetDisplay();
CaIpmQueryInfo queryInfo(pDoc, OT_MON_LOGPROCESS, pUps, (LPVOID)&structData, sizeof(structData));
bOK = IPM_QueryInfo (&queryInfo, listInfoStruct);
if (bOK)
{
while (!listInfoStruct.IsEmpty())
{
pData = (LOGPROCESSDATAMIN*)listInfoStruct.RemoveHead();
GetDisplayInfo (pData, strID, strPID, strType, strOpenDB, strWrite, strForce, strWait, strBegin, strEnd);
AddProcess (strID, strPID, strType, strOpenDB, strWrite, strForce, strWait, strBegin, strEnd, pData);
}
}
return 0L;
}
catch (CMemoryException* e)
{
theApp.OutOfMemoryMessage();
e->Delete();
}
catch (CeIpmException e)
{
AfxMessageBox (e.GetReason(), MB_ICONEXCLAMATION|MB_OK);
}
while (!listInfoStruct.IsEmpty())
delete (LOGPROCESSDATAMIN*)listInfoStruct.RemoveHead();
return 0L;
}
void UpdateProcesses()
{
int i;
ULONG l;
LV_ITEM item;
LPPROCESS_PAGE_LIST_ITEM pData;
SendMessage(hProcessPageListCtrl, WM_SETREDRAW, FALSE, 0);
/* Remove old processes */
for (i = 0; i < ListView_GetItemCount(hProcessPageListCtrl); i++)
{
memset(&item, 0, sizeof (LV_ITEM));
item.mask = LVIF_PARAM;
item.iItem = i;
(void)ListView_GetItem(hProcessPageListCtrl, &item);
pData = (LPPROCESS_PAGE_LIST_ITEM)item.lParam;
if (!ProcessRunning(pData->ProcessId))
{
(void)ListView_DeleteItem(hProcessPageListCtrl, i);
HeapFree(GetProcessHeap(), 0, pData);
}
}
/* Check for difference in listview process and performance process counts */
if (ListView_GetItemCount(hProcessPageListCtrl) != PerfDataGetProcessCount())
{
/* Add new processes by checking against the current items */
for (l = 0; l < PerfDataGetProcessCount(); l++)
{
AddProcess(l);
}
}
if (TaskManagerSettings.SortColumn != -1)
{
(void)ListView_SortItems(hProcessPageListCtrl, ProcessPageCompareFunc, NULL);
}
SendMessage(hProcessPageListCtrl, WM_SETREDRAW, TRUE, 0);
/* Select first item if any */
if ((ListView_GetNextItem(hProcessPageListCtrl, -1, LVNI_FOCUSED | LVNI_SELECTED) == -1) &&
(ListView_GetItemCount(hProcessPageListCtrl) > 0) && !bProcessPageSelectionMade)
{
ListView_SetItemState(hProcessPageListCtrl, 0, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
bProcessPageSelectionMade = TRUE;
}
/*
else
{
bProcessPageSelectionMade = FALSE;
}
*/
}
Process::ProcessModel& AddOnlyProcessToConstraint::redo(ConstraintModel& constraint) const
{
// Create process model
auto proc = context.components.factory<Process::ProcessList>().get(m_processName)
->makeModel(
constraint.duration.defaultDuration(), // TODO should maybe be max ?
m_createdProcessId,
&constraint);
AddProcess(constraint, proc);
return *proc;
}
void BatchGUI::SetupConnect()
{
connect( this->ui.addButton, SIGNAL(clicked()), this, SLOT(AddProcess()) );
//
connect( this->ui.beginButton, SIGNAL(clicked()), this, SLOT(BeginProcess()) );
//
connect( this->ui.appButton, SIGNAL(clicked()), this, SLOT(SelectFile()) );
//
connect( this->ui.cleanButton, SIGNAL(clicked()), this, SLOT(CleanAll()) );
//
connect( this->ui.stopButton, SIGNAL(clicked()), this, SLOT(StopAll()) );
//
connect( this->ui.resumeButton, SIGNAL(clicked()), this, SLOT(Resume()) );
//
connect( this->ui.resetButton, SIGNAL(clicked()), this, SLOT(ResetAll()) );
return;
}
//------------------------------------------------------------------------------
// MVATrain
//------------------------------------------------------------------------------
void MVATrain(TString signal)
{
TFile* outputfile = TFile::Open(trainingdir + signal + ".root", "recreate");
// Factory
//----------------------------------------------------------------------------
TMVA::Factory* factory = new TMVA::Factory(signal, outputfile,
"!V:!Silent:Color:DrawProgressBar:Transformations=I;D;P;G,D:AnalysisType=Classification");
// Get the trees
//----------------------------------------------------------------------------
_mctree.clear();
AddProcess("signal", signal);
AddProcess("background", "HZJ_HToWW_M125");
AddProcess("background", "ggZH_HToWW_M125");
// AddProcess("background", "14_HZ");
// AddProcess("background", "10_HWW");
// AddProcess("background", "06_WW");
// AddProcess("background", "02_WZTo3LNu");
// AddProcess("background", "03_ZZ");
// AddProcess("background", "11_Wg");
// AddProcess("background", "07_ZJets");
// AddProcess("background", "09_TTV");
// AddProcess("background", "05_ST");
// AddProcess("background", "00_Fakes");
Double_t weight = 1.0;
factory->AddSignalTree(_signaltree, weight);
for (UInt_t i=0; i<_mctree.size(); i++) factory->AddBackgroundTree(_mctree[i], weight);
factory->SetWeightExpression("eventW");
// Add variables
//----------------------------------------------------------------------------
// Be careful with the order: it must be respected at the reading step
// factory->AddVariable("<var1>+<var2>", "pretty title", "unit", 'F');
// factory->AddVariable("channel", "", "", 'F');
factory->AddVariable("metPfType1", "", "", 'F');
factory->AddVariable("m2l", "", "", 'F');
// factory->AddVariable("njet", "", "", 'F');
// factory->AddVariable("nbjet20cmvav2l", "", "", 'F');
factory->AddVariable("lep1pt", "", "", 'F');
factory->AddVariable("lep2pt", "", "", 'F');
// factory->AddVariable("jet1pt", "", "", 'F');
factory->AddVariable("jet2pt", "", "", 'F');
factory->AddVariable("mtw1", "", "", 'F');
factory->AddVariable("dphill", "", "", 'F');
factory->AddVariable("dphilep1jet1", "", "", 'F');
// factory->AddVariable("dphilep1jet2", "", "", 'F');
// factory->AddVariable("dphilmet1", "", "", 'F');
// factory->AddVariable("dphilep2jet1", "", "", 'F');
// factory->AddVariable("dphilep2jet2", "", "", 'F');
// factory->AddVariable("dphilmet2", "", "", 'F');
// factory->AddVariable("dphijj", "", "", 'F');
// factory->AddVariable("dphijet1met", "", "", 'F');
// factory->AddVariable("dphijet2met", "", "", 'F');
factory->AddVariable("dphillmet", "", "", 'F');
// Preselection cuts and preparation
//----------------------------------------------------------------------------
factory->PrepareTrainingAndTestTree("", ":nTrain_Signal=0:nTest_Signal=0:nTrain_Background=0:nTest_Background=0:SplitMode=Alternate:MixMode=Random:!V");
// Book MVA
//----------------------------------------------------------------------------
factory->BookMethod(TMVA::Types::kMLP, "MLP",
"H:!V:NeuronType=sigmoid:VarTransform=N:NCycles=600:HiddenLayers=25,10:TestRate=5:!UseRegulator");
// Train, test and evaluate MVA
//----------------------------------------------------------------------------
factory->TrainAllMethods(); // Train using the set of training events
factory->TestAllMethods(); // Evaluate using the set of test events
factory->EvaluateAllMethods(); // Evaluate and compare performance
// Save the output
//----------------------------------------------------------------------------
outputfile->Close();
delete factory;
}
/*
* AccLoadProg - create a new process for debugging
*/
trap_retval ReqProg_load( void )
{
char *parm;
char *src;
char *dst;
char *endsrc;
char exe_name[PATH_MAX];
char ch;
BOOL rc;
int len;
MYCONTEXT con;
thread_info *ti;
HANDLE handle;
prog_load_req *acc;
prog_load_ret *ret;
header_info hi;
WORD stack;
WORD version;
DWORD pid;
DWORD pid_started;
DWORD cr_flags;
char *buff = NULL;
size_t nBuffRequired = 0;
char *dll_name;
char *service_name;
char *dll_destination;
char *service_parm;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
parm = GetInPtr( sizeof( *acc ) );
/*
* reset status variables
*/
LastExceptionCode = -1;
DebugString = NULL;
DebugeeEnded = FALSE;
RemoveAllThreads();
FreeLibList();
DidWaitForDebugEvent = FALSE;
DebugeePid = 0;
DebugeeTid = 0;
SupportingExactBreakpoints = 0;
/*
* check if pid is specified
*/
ParseServiceStuff( parm, &dll_name, &service_name, &dll_destination, &service_parm );
pid = 0;
src = parm;
/*
// Just to be really safe!
*/
nBuffRequired = GetTotalSize() + PATH_MAX + 16;
if( NULL == ( buff = malloc( nBuffRequired ) ) ) {
ret->err = ERROR_NOT_ENOUGH_MEMORY;
return( sizeof( *ret ) );
}
if( *src == '#' ) {
src++;
pid = strtoul( src, &endsrc, 16 );
if( pid == 0 ) {
pid = -1;
}
strcpy( buff, endsrc );
} else {
while( isdigit( *src ) ) {
src++;
}
if( *src == 0 && src != parm ) {
pid = atoi( parm );
}
}
/*
* get program to debug. If the user has specified a pid, then
* skip directly to doing a DebugActiveProcess
*/
IsWOW = FALSE;
#if !defined( MD_x64 )
IsDOS = FALSE;
#endif
if( pid == 0 ) {
if( FindFilePath( parm, exe_name, ExtensionList ) != 0 ) {
ret->err = ERROR_FILE_NOT_FOUND;
goto error_exit;
}
/*
* Get type of application
*/
handle = CreateFile( (LPTSTR)exe_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
if( handle == INVALID_HANDLE_VALUE ) {
ret->err = GetLastError();
goto error_exit;
}
GetFullPathName( exe_name, MAX_PATH, CurrEXEName, NULL );
/*
* get the parm list
*/
if( strchr( CurrEXEName, ' ' ) != NULL ) {
strcpy( buff, "\"" );
strcat( buff, CurrEXEName );
strcat( buff, "\"" );
} else {
strcpy( buff, CurrEXEName );
}
dst = &buff[strlen( buff )];
src = parm;
while( *src != 0 ) {
++src;
}
// parm layout
// <--parameters-->0<--program_name-->0<--arguments-->0
//
for( len = GetTotalSize() - sizeof( *acc ) - (src - parm) - 1; len > 0; --len ) {
ch = *src;
if( ch == 0 ) {
ch = ' ';
}
*dst = ch;
++dst;
++src;
}
*dst = 0;
cr_flags = DEBUG_ONLY_THIS_PROCESS;
if( !GetEXEHeader( handle, &hi, &stack ) ) {
ret->err = GetLastError();
CloseHandle( handle );
goto error_exit;
}
if( hi.sig == EXE_PE ) {
if( IS_PE64( hi.u.peh ) ) {
DebugeeSubsystem = PE64( hi.u.peh ).subsystem;
} else {
DebugeeSubsystem = PE32( hi.u.peh ).subsystem;
#if defined( MD_x64 )
IsWOW = TRUE;
#endif
}
if( DebugeeSubsystem == SS_WINDOWS_CHAR ) {
cr_flags |= CREATE_NEW_CONSOLE;
}
#if !defined( MD_x64 )
} else if( hi.sig == EXE_NE ) {
IsWOW = TRUE;
/*
* find out the pid of WOW, if it is already running.
*/
pVDMEnumProcessWOW( EnumWOWProcessFunc, (LPARAM)&pid );
if( pid != 0 ) {
version = LOWORD( GetVersion() );
if( LOBYTE( version ) == 3 && HIBYTE( version ) < 50 ) {
int kill = MessageBox( NULL, TRP_NT_wow_warning, TRP_The_WATCOM_Debugger, MB_APPLMODAL + MB_YESNO );
if( kill == IDYES ) {
DWORD axs = PROCESS_TERMINATE+STANDARD_RIGHTS_REQUIRED;
HANDLE hprocess = OpenProcess( axs, FALSE, pid );
if( hprocess != 0 && TerminateProcess( hprocess, 0 ) ) {
CloseHandle( hprocess );
pid = 0;
}
}
} else {
cr_flags |= CREATE_SEPARATE_WOW_VDM;
pid = 0; // always start a new VDM.
}
}
if( pid != 0 ) {
ret->err = GetLastError();
CloseHandle( handle );
goto error_exit;
}
} else {
IsDOS = TRUE;
#endif
}
CloseHandle( handle );
}
/*
* start the debugee
*/
pid_started = pid;
if( *dll_name ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_DLLNAME );
strcat( buff, dll_name );
}
if( *service_name ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_SERVICE );
strcat( buff, service_name );
}
if( *dll_destination ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_COPYDIR );
strcat( buff, dll_destination );
}
if( *service_parm ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_SERVICEPARM );
strcat( buff, service_parm );
}
ret->err = StartControlThread( buff, &pid_started, cr_flags );
if( ret->err != 0 ) {
goto error_exit;
}
/*
* CREATE_PROCESS_DEBUG_EVENT will always be the first debug event.
* If it is not, then something is horribly wrong.
*/
rc = MyWaitForDebugEvent();
if( !rc || ( DebugEvent.dwDebugEventCode != CREATE_PROCESS_DEBUG_EVENT ) || ( DebugEvent.dwProcessId != pid_started ) ) {
ret->err = GetLastError();
goto error_exit;
}
ProcessInfo.pid = DebugEvent.dwProcessId;
ProcessInfo.process_handle = DebugEvent.u.CreateProcessInfo.hProcess;
ProcessInfo.base_addr = DebugEvent.u.CreateProcessInfo.lpBaseOfImage;
AddProcess( &hi );
AddThread( DebugEvent.dwThreadId, DebugEvent.u.CreateProcessInfo.hThread, DebugEvent.u.CreateProcessInfo.lpStartAddress );
DebugeePid = DebugEvent.dwProcessId;
DebugeeTid = DebugEvent.dwThreadId;
LastDebugEventTid = DebugEvent.dwThreadId;
#if defined( MD_x86 )
#ifdef WOW
if( IsWOW ) {
ret->flags = LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
/*
* we use our own CS and DS as the Flat CS and DS, for lack
* of anything better
*/
FlatDS = GetDS();
FlatCS = GetCS();
if( !executeUntilVDMStart() ) {
ret->err = GetLastError();
goto error_exit;
}
if( pid ) {
addAllWOWModules();
} else {
addKERNEL();
}
/*
* we save the starting CS:IP of the WOW app, since we will use
* it to force execution of code later
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
WOWAppInfo.segment = ( WORD ) con.SegCs;
WOWAppInfo.offset = ( WORD ) con.Eip;
con.SegSs = con.SegDs; // Wow lies about the stack segment. Reset it
con.Esp = stack;
MySetThreadContext( ti, &con );
} else if( IsDOS ) {
// TODO! Clean up this code
ret->flags = 0; //LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
/*
* we use our own CS and DS as the Flat CS and DS, for lack
* of anything better
*/
FlatDS = GetDS();
FlatCS = GetCS();
if( !executeUntilVDMStart() ) {
ret->err = GetLastError();
goto error_exit;
}
#if 0
if( pid ) {
addAllWOWModules();
} else {
addKERNEL();
}
#endif
/*
* we save the starting CS:IP of the WOW app, since we will use
* it to force execution of code later
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
WOWAppInfo.segment = ( WORD )con.SegCs;
WOWAppInfo.offset = ( WORD )con.Eip;
con.SegSs = con.SegDs; // Wow lies about the stack segment. Reset it
con.Esp = stack;
MySetThreadContext( ti, &con );
} else {
#else
{
#endif
#else
{
#endif
LPVOID base;
if( pid == 0 ) {
base = (LPVOID)DebugEvent.u.CreateProcessInfo.lpStartAddress;
} else {
base = 0;
}
ret->flags = LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
if( executeUntilStart( pid != 0 ) ) {
LPVOID old;
/*
* make the application load our DLL, so that we can have it
* run code out of it. One small note: this will not work right
* if the app does not load our DLL at the same address the
* debugger loaded it at!!!
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
old = (LPVOID)AdjustIP( &con, 0 );
if( base != 0 ) {
SetIP( &con, base );
}
MySetThreadContext( ti, &con );
SetIP( &con, old );
MySetThreadContext( ti, &con );
}
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
#if defined( MD_x86 )
FlatCS = con.SegCs;
FlatDS = con.SegDs;
#endif
ret->flags |= LD_FLAG_IS_BIG;
}
ret->flags |= LD_FLAG_HAVE_RUNTIME_DLLS;
if( pid != 0 ) {
ret->flags |= LD_FLAG_IS_STARTED;
}
ret->mod_handle = 0;
error_exit:
if( buff ) {
free( buff );
buff = NULL;
}
return( sizeof( *ret ) );
}
trap_retval ReqProg_kill( void )
{
prog_kill_ret *ret;
ret = GetOutPtr( 0 );
ret->err = 0;
DelProcess( TRUE );
StopControlThread();
return( sizeof( *ret ) );
}
int main(int argc, char *argv[])
{
char hostname[80];
struct hostent *hostPtr;
struct sockaddr_in serverName;
fd_set ReadSet;
struct timeval TimeOut;
MESSAGE msg;
int on;
int status;
Init();
GroupPort=DEFAULT_PORT;
switch(argc)
{
case 2:
GroupPort=atoi(argv[1]);
//FALLTHROUGH
case 1:
break;
default:
fprintf(stderr, "Usage: %s [ServerPort]\n", argv[0]);
exit(1);
}/* switch(argc) */
s=socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);
if(s==INVALID_SOCKET)
ErrorExit("socket()");
on=1;
status=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,
(char *)&on,sizeof(on));
if(status==SOCKET_ERROR)
ErrorExit("setsockopt(...,SO_REUSEADDR,...)");
status=setsockopt(s,SOL_SOCKET,SO_BROADCAST,
(char *)&on,sizeof(on));
if(status==SOCKET_ERROR)
ErrorExit("setsockopt(...,SO_BROADCAST,...)");
/*
* Find out who I am.
*/
status=_GetHostName(hostname,sizeof(hostname));
if(status==SOCKET_ERROR)
ErrorExit("_GetHostName()");
hostPtr=gethostbyname(hostname);
if(hostPtr==NULL)
ErrorExit("gethostbyname()");
ZERO(serverName);
serverName.sin_family=AF_INET;
serverName.sin_port=htons(GroupPort);
serverName.sin_addr.s_addr=INADDR_ANY;
/* A "feature" of Linux is that if I bind to a specific address
* it assumes that I don't want to get broadcasts.
*
* memcpy(&serverName.sin_addr,hostPtr->h_addr,hostPtr->h_length);
*/
status=bind(s,(struct sockaddr *)&serverName,sizeof(serverName));
if(status==SOCKET_ERROR)
ErrorExit("bind()");
/*
* Init Globals
*/
Me.pid=getpid();
Me.IP=*((DWORD *)hostPtr->h_addr);
printf("Hello. My Unique ID is %X %X.\n\n",Me.pid,Me.IP);
/*
* Join the group
*/
TRACE("Broadcasting JOIN");
msg.OpCode=JOIN;
msg.To=BcastAddr;
Send(&msg);
/*
* Start an election (Once we know who is in the group.)
*/
TRACE("Set Election Timer");
AYATimer=time(NULL)+AYA_TIMEOUT;
while(TRUE)
{
TimeOut.tv_sec=1;
TimeOut.tv_usec=0;
FD_ZERO(&ReadSet);
FD_SET(s,&ReadSet);
status=select(s+1,&ReadSet,NULL,NULL,&TimeOut);
if(status)
{
if(Recv(&msg))
{
switch(msg.OpCode)
{
case AYA:
TRACE("Received AYA");
msg.OpCode=IamA;
msg.To=msg.From;
Send(&msg);
break;
case IamA:
TRACE("Received IamA");
if(IsEqual(&msg.From,&Coord))
bCoordAlive=TRUE;
else
TRACE("IamA--Wrong Coordinator");
break;
case ELECT:
TRACE("Received ELECT");
msg.OpCode=ACK_ELECT;
msg.To=msg.From;
Send(&msg);
StartElection();
break;
case ACK_ELECT:
TRACE("Received ACK_ELECT");
CancelElection(&msg);
break;
case JOIN:
TRACE("Received JOIN");
//Broadcast can include myself
if(IsEqual(&msg.From,&Me))
{
TRACE("JOIN--From myself!");
break;
}
AddProcess(&msg.From);
msg.OpCode=WELCOME;
msg.To=msg.From;
Send(&msg);
//It looks like we need to restart our election
if(bElect && IsBigger(&msg.From,&Me))
{
bElect=FALSE;
StartElection();
}
break;
case WELCOME:
TRACE("Received WELCOME");
AddProcess(&msg.From);
break;
case IM_COORD:
TRACE("Received IM_COORD");
SetCoord(&msg.From);
break;
case LEAVE:
TRACE("Received LEAVE");
RemoveProcess(&msg.From);
if(IsEqual(&msg.From,&Coord))
StartElection();
}//switch(OpCode
}//if(Recv
}//if(status
CheckElectionTimer();
CheckAYATimer();
CheckAYAInterval();
}//while(1
return 0;
}//main
//------------------------------------------------------------------------------
// MVATrain
//------------------------------------------------------------------------------
void MVATrain(float metPfType1_cut, float mt2ll_cut, TString signal)
{
TFile* outputfile = TFile::Open(trainingdir + signal + ".root", "recreate");
// Factory
//----------------------------------------------------------------------------
TMVA::Factory* factory = new TMVA::Factory(signal, outputfile,
// "!V:!Silent:Color:DrawProgressBar:Transformations=I;D;P;G,D:AnalysisType=Classification");
"!V:!Silent:Color:DrawProgressBar:AnalysisType=Classification");
// Get the trees
//----------------------------------------------------------------------------
_mctree.clear();
AddProcess("signal" , signal);//"01_Data_reduced_1outof6"); //signal
AddProcess("background", "04_TTTo2L2Nu");
/*AddProcess("background", "14_HZ");
AddProcess("background", "10_HWW");
AddProcess("background", "06_WW");
AddProcess("background", "02_WZTo3LNu");
AddProcess("background", "03_VZ");
AddProcess("background", "11_Wg");
AddProcess("background", "07_ZJets");
AddProcess("background", "09_TTV");
AddProcess("background", "05_ST");
AddProcess("background", "00_Fakes_reduced_1outof6");*/
Double_t weight = 1.0;
factory->AddSignalTree(_signaltree, weight);
for (UInt_t i=0; i<_mctree.size(); i++) factory->AddBackgroundTree(_mctree[i], weight);
factory->SetWeightExpression("eventW");
// Add variables
//----------------------------------------------------------------------------
// Be careful with the order: it must be respected at the reading step
// factory->AddVariable("<var1>+<var2>", "pretty title", "unit", 'F');
factory->AddVariable("newdarkpt" , "", "", 'F');
//factory->AddVariable("topRecoW" , "", "", 'F');
//factory->AddVariable("lep1pt" , "", "", 'F');
//factory->AddVariable("lep1eta" , "", "", 'F');
//factory->AddVariable("lep1phi" , "", "", 'F');
//factory->AddVariable("lep1mass" , "", "", 'F');
//factory->AddVariable("lep2pt" , "", "", 'F');
//factory->AddVariable("lep2eta" , "", "", 'F');
//factory->AddVariable("lep2phi" , "", "", 'F');
//factory->AddVariable("lep2mass" , "", "", 'F');
//factory->AddVariable("jet1pt " , "", "", 'F');
//factory->AddVariable("jet1eta" , "", "", 'F');
//factory->AddVariable("jet1phi" , "", "", 'F');
//factory->AddVariable("jet1mass" , "", "", 'F');
//factory->AddVariable("jet2pt" , "", "", 'F');
//factory->AddVariable("jet2eta" , "", "", 'F');
//factory->AddVariable("jet2phi" , "", "", 'F');
//factory->AddVariable("jet2mass" , "", "", 'F');
factory->AddVariable("metPfType1" , "", "", 'F');
//factory->AddVariable("metPfType1Phi", "", "", 'F');
//factory->AddVariable("m2l" , "", "", 'F');
factory->AddVariable("mt2ll" , "", "", 'F');
//factory->AddVariable("mt2lblb" , "", "", 'F');
//factory->AddVariable("mtw1" , "", "", 'F');
//factory->AddVariable("mtw2" , "", "", 'F');
//factory->AddVariable("ht" , "", "", 'F');
//factory->AddVariable("htjets" , "", "", 'F');
//factory->AddVariable("htnojets" , "", "", 'F');
//factory->AddVariable("njet" , "", "", 'F');
//factory->AddVariable("nbjet30csvv2l", "", "", 'F');
//factory->AddVariable("nbjet30csvv2m", "", "", 'F');
//factory->AddVariable("nbjet30csvv2t", "", "", 'F');
//factory->AddVariable("dphijet1met" , "", "", 'F');
//factory->AddVariable("dphijet2met" , "", "", 'F');
//factory->AddVariable("dphijj" , "", "", 'F');
//factory->AddVariable("dphijjmet" , "", "", 'F');
//factory->AddVariable("dphill" , "", "", 'F');
//factory->AddVariable("dphilep1jet1" , "", "", 'F');
//factory->AddVariable("dphilep1jet2" , "", "", 'F');
//factory->AddVariable("dphilep2jet1" , "", "", 'F');
//factory->AddVariable("dphilep2jet2" , "", "", 'F');
//factory->AddVariable("dphilmet1" , "", "", 'F');
//factory->AddVariable("dphilmet2" , "", "", 'F');
factory->AddVariable("dphillmet" , "", "", 'F');
//factory->AddVariable("sphericity" , "", "", 'F');
//factory->AddVariable("alignment" , "", "", 'F');
//factory->AddVariable("planarity" , "", "", 'F');
// Preselection cuts and preparation
//----------------------------------------------------------------------------
//factory->PrepareTrainingAndTestTree(Form("metPfType1>%5.2f&&mt2ll>%5.2f&&newdarkpt>0.", metPfType1_cut, mt2ll_cut), "NormMode=EqualNumEvents:nTrain_Signal=80:nTest_Signal=80:nTrain_Background=400:nTest_Background=400:!V");
factory->PrepareTrainingAndTestTree("mt2ll>100.&&newdarkpt>0.&&metPfType1>80.", "NormMode=EqualNumEvents:nTrain_Signal=0:nTest_Signal=0:nTrain_Background=0:nTest_Background=0:!V");
// Book MVA
//----------------------------------------------------------------------------
factory->BookMethod(TMVA::Types::kMLP, "MLP01",
"H:!V:NeuronType=sigmoid:NCycles=500:VarTransform=Norm:HiddenLayers=6,3:TestRate=1:LearningRate=0.005");
//factory->BookMethod(TMVA::Types::kMLP, "MLP01",
// "H:!V:NeuronType=sigmoid:NCycles=500:VarTransform=Norm:HiddenLayers=4,4:TestRate=3:LearningRate=0.005");
//factory->BookMethod(TMVA::Types::kMLP, "MLP02",
// "H:!V:NeuronType=sigmoid:NCycles=40:VarTransform=Norm:HiddenLayers=20,10:TestRate=3:LearningRate=0.005");
//factory->BookMethod(TMVA::Types::kMLP, "MLP03",
// "H:!V:NeuronType=sigmoid:NCycles=30:VarTransform=Norm:HiddenLayers=20,20:TestRate=3:LearningRate=0.005");
//factory->BookMethod(TMVA::Types::kBDT, "BDT04", "NTrees=50:MaxDepth=2" );
//factory->BookMethod(TMVA::Types::kBDT, "BDT05", "NTrees=50:MaxDepth=3" );
// Train, test and evaluate MVA
//----------------------------------------------------------------------------
factory->TrainAllMethods(); // Train using the set of training events
factory->TestAllMethods(); // Evaluate using the set of test events
factory->EvaluateAllMethods(); // Evaluate and compare performance
// Save the output
//----------------------------------------------------------------------------
outputfile->Close();
delete factory;
}
unsigned ReqProg_load( void )
{
char **args;
char *parms;
char *parm_start;
int i;
char exe_name[PATH_MAX];
char *name;
pid_t save_pgrp;
prog_load_req *acc;
prog_load_ret *ret;
unsigned len;
int status;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
last_sig = -1;
have_rdebug = FALSE;
dbg_dyn = NULL;
at_end = FALSE;
parms = (char *)GetInPtr( sizeof( *acc ) );
parm_start = parms;
len = GetTotalSize() - sizeof( *acc );
if( acc->true_argv ) {
i = 1;
for( ;; ) {
if( len == 0 ) break;
if( *parms == '\0' ) {
i++;
}
++parms;
--len;
}
args = alloca( i * sizeof( *args ) );
parms = parm_start;
len = GetTotalSize() - sizeof( *acc );
i = 1;
for( ;; ) {
if( len == 0 ) break;
if( *parms == '\0' ) {
args[i++] = parms + 1;
}
++parms;
--len;
}
args[i - 1] = NULL;
} else {
while( *parms != '\0' ) {
++parms;
--len;
}
++parms;
--len;
i = SplitParms( parms, NULL, len );
args = alloca( (i + 2) * sizeof( *args ) );
args[SplitParms( parms, &args[1], len ) + 1] = NULL;
}
args[0] = parm_start;
attached = TRUE;
pid = RunningProc( args[0], &name );
if( pid == 0 || ptrace( PTRACE_ATTACH, pid, NULL, NULL ) == -1 ) {
attached = FALSE;
args[0] = name;
if( FindFilePath( TRUE, args[0], exe_name ) == 0 ) {
exe_name[0] = '\0';
}
save_pgrp = getpgrp();
setpgid( 0, OrigPGrp );
pid = fork();
if( pid == -1 )
return( 0 );
if( pid == 0 ) {
if( ptrace( PTRACE_TRACEME, 0, NULL, NULL ) < 0 ) {
exit( 1 );
}
execve( exe_name, (const char **)args, (const char **)dbg_environ );
exit( 1 ); /* failsafe */
}
setpgid( 0, save_pgrp );
} else if( pid ) {
GetExeNameFromPid( pid, exe_name, PATH_MAX );
}
ret->flags = 0;
ret->mod_handle = 0;
if( (pid != -1) && (pid != 0) ) {
int status;
ret->task_id = pid;
ret->flags |= LD_FLAG_IS_PROT | LD_FLAG_IS_32;
/* wait until it hits _start (upon execve) or
gives us a SIGSTOP (if attached) */
if( waitpid( pid, &status, 0 ) < 0 )
goto fail;
if( !WIFSTOPPED( status ) )
goto fail;
if( attached ) {
ret->flags |= LD_FLAG_IS_STARTED;
if( WSTOPSIG( status ) != SIGSTOP )
goto fail;
} else {
if( WSTOPSIG( status ) != SIGTRAP )
goto fail;
}
#if defined( MD_x86 )
if( !GetFlatSegs( &flatCS, &flatDS ) )
goto fail;
#endif
dbg_dyn = GetDebuggeeDynSection( exe_name );
AddProcess();
errno = 0;
}
ret->err = errno;
if( ret->err != 0 ) {
pid = 0;
}
CONV_LE_32( ret->err );
CONV_LE_32( ret->task_id );
CONV_LE_32( ret->mod_handle );
return( sizeof( *ret ) );
fail:
if( pid != 0 && pid != -1 ) {
if( attached ) {
ptrace( PTRACE_DETACH, pid, NULL, NULL );
attached = FALSE;
} else {
ptrace( PTRACE_KILL, pid, NULL, NULL );
waitpid( pid, &status, 0 );
}
}
pid = 0;
CONV_LE_32( ret->err );
CONV_LE_32( ret->task_id );
CONV_LE_32( ret->mod_handle );
return( 0 );
}