void D3PDSelector::Begin(TTree * /*tree*/)
{
   // The Begin() function is called at the start of the query.
   // When running with PROOF Begin() is only called on the client.
   // The tree argument is deprecated (on PROOF 0 is passed).
   std::cout << "BEGIN" << std::endl;



   TString option = GetOption();
}

void esdAna::SlaveBegin(TTree *tree)
{
   // The SlaveBegin() function is called after the Begin() function.
   // When running with PROOF SlaveBegin() is called on each slave server.
   // The tree argument is deprecated (on PROOF 0 is passed).

  
     Init(tree);

   TString option = GetOption();

}

bool wxOptionValue::GetOption(const wxString& name, int *v1, int *v2, int *v3,
                              const wxString& delims) const
{
    wxArrayInt intArr;
    if (GetOption(name, intArr, 3, delims) != 3)
        return false;

    if (v1) *v1 = intArr[0];
    if (v2) *v2 = intArr[1];
    if (v3) *v3 = intArr[2];
    return true;
}

void generate_corrections_TRB3_dataStructureV2::Begin(TTree * /*tree*/)
{
   TString option = GetOption();
   
   binsHist = new TH1F*[channelCount];
   correctionsHist = new TH1F*[channelCount];
   for(int i = 0; i < channelCount; i++){
     binsHist[i] = new TH1F(Form("binsHist%d", i), Form("binsHist%d", i), 500, 0, 5000);
     correctionsHist[i] = new TH1F(Form("correction%d", i), Form("correction%d", i), 500, 0, 500);
   }
     
  }

void MySelector::Begin(TTree * /*tree*/)
{
   // The Begin() function is called at the start of the query.
   // When running with PROOF Begin() is only called on the client.
   // The tree argument is deprecated (on PROOF 0 is passed).

   TString option = GetOption();

   // some time measurement
   tBegin.Set(); printf("*==* ---------- Begin of Job ----------");
   tBegin.Print();
}

//_____________________________________________________________________________
void ProofSelectorMyCutFlow::Begin(TTree * /*tree*/)
{
  // The Begin() function is called at the start of the query.
  // When running with PROOF Begin() is only called on the client.
  // The tree argument is deprecated (on PROOF 0 is passed).
  
  cout << "start Begin " << endl;
  TString option = GetOption();
  cout << "end  Begin" << endl;
  
  
}

// Build the SAM keyboard matrix from the current PC state
void SetSamKeyState ()
{
    // No SAM keys are pressed initially
    ReleaseAllSamKeys();

    // Set any SIP selection on the SAM keyboard
    if (nSipKey >= 0 && nSipKey != SK_NONE) PressSamKey(nSipKey);
    if (nSipMods & SMOD_SHIFT) PressSamKey(SK_SHIFT);
    if (nSipMods & SMOD_SYMBOL) PressSamKey(SK_SYMBOL);
    if (nSipMods & SMOD_CONTROL) PressSamKey(SK_CONTROL);

    // If the control pad or hardware keys are pressed, activate the appropriate SAM key
    for (int i = 0 ; i < sizeof(anHwKeys)/sizeof(anHwKeys[0]) ; i++)
    {
        if (IsPressed(anHwKeys[i]))
            PressSamKey(anKeyMap[i]);
    }

    // Left and right shift keys are equivalent, and also complementary!
    bool fShiftToggle = IsPressed(VK_LSHIFT) && IsPressed(VK_RSHIFT);

    // Process the key combinations required for the mode we're in
    switch (GetOption(keymapping))
    {
        // SAM keys
        case 1:
            ProcessKeyTable(asSamSymbols);
            ProcessKeyTable(asSamMappings);
            break;

        // Spectrum mappings
        case 2:
            ProcessKeyTable(asSpectrumSymbols);
            ProcessKeyTable(asSpectrumMappings);
            break;
    }

    // Toggle shift if both shift keys are down to allow shifted versions of keys that are
    // shifted on the PC but unshifted on the SAM
    if (fShiftToggle)
        ReleaseKey(VK_SHIFT);

    // Process the simple key mappings
    ProcessKeyTable(asSamKeys);

    // Update the SIP if it may have changed
    if (fSipDirty)
    {
        InvalidateRect(g_hwndSIP, NULL, FALSE);
        fSipDirty = false;
    }
}

logical DLInterpreter :: LISTEXPRESSION ( )
{
  logical                 term = NO;
BEGINSEQ
  if ( !GetOption('h') )
    ShowExpression();
  else
  {
//                                 :   
    Output("list current expression: ListExpression|l \n");
    if ( !GetOption('d') )                           LEAVESEQ

//                   1         2         3         4         5         6         7         8
//          12345678901234567890123456789012345678901234567890123456789012345678901234567890   
    Output("  The command lists the current expression \n");
    Output("  \n");
//                        -
  }

ENDSEQ
  return(term);
}

logical DLInterpreter :: LISTCURRENTLINE ( )
{
  logical                 term = NO;
BEGINSEQ
  if ( !GetOption('h') )
    ShowCurrentLine();
  else
  {
//                                 :   
    Output("list current line      : ListCurrentLine|dlc \n");
    if ( !GetOption('d') )                           LEAVESEQ

//                   1         2         3         4         5         6         7         8
//          12345678901234567890123456789012345678901234567890123456789012345678901234567890   
    Output("  The command lists the line with the current statement.\n");
    Output("  \n");
//                        -
  }

ENDSEQ
  return(term);
}

logical DLInterpreter :: RESETBREAK ( )
{
  logical                 term = NO;
BEGINSEQ
  if ( !GetOption('h') )
    SetBreakPoint(NO);      
  else
  {
//                                 :   
    Output("reset break point      : ResetBreak|drb \n");
    if ( !GetOption('d') )                           LEAVESEQ

//                   1         2         3         4         5         6         7         8
//          12345678901234567890123456789012345678901234567890123456789012345678901234567890   
    Output("  The command sets a break point at the current position.\n");
    Output("  \n");
//                        -
  }

ENDSEQ
  return(term);
}

void UEAnalysisSelectorRootple::Begin(TTree * /*tree*/)
{
   // The Begin() function is called at the start of the query.
   // When running with PROOF Begin() is only called on the client.
   // The tree argument is deprecated (on PROOF 0 is passed).

   TString option = GetOption();
   
   std::cout << "UEAnalysisSelectorRootple Begin " <<std::endl;
   ue = new UEAnalysisUE();
   jets = new UEAnalysisJets();
   mpi = new UEAnalysisMPI();
}

static void ProcStatus( void )
{
    disp_optn   optn;

    optn = GetOption();
    if( optn == OPEN ) {
        WndCreateStatusWindow( &WndStatusColour );
    } else if( optn == CLOSE ) {
        WndCloseStatusWindow();
    } else {
        Error( ERR_LOC, LIT_ENG( ERR_BAD_OPTION ), GetCmdName( CMD_DISPLAY ) );
    }
}

int getopt(int argc, char **argv, char *optstring)
{
	int i;
	
	i = GetOption(argc, argv, optstring, &optarg);

	if (i==0 || i==1) return EOF;
	else if (i==-1) {
		char c=*(optarg+1);
		return c;
	}
	else return i;
}

void TagAndProbe::Begin(TTree * /*tree*/)
{
	// The Begin() function is called at the start of the query.
	// When running with PROOF Begin() is only called on the client.
	// The tree argument is deprecated (on PROOF 0 is passed).
	
	TString option = GetOption();
	tTagAndProbeMuIso_=NULL;
	tTagAndProbeMuReco_=NULL;
	tTagAndProbeElecIso_=NULL;
	tTagAndProbeElecReco_=NULL;
	
}

//_____________________________________________________________________________
void ProofFriends::Begin(TTree * /*tree*/)
{
   // The Begin() function is called at the start of the query.
   // When running with PROOF Begin() is only called on the client.
   // The tree argument is deprecated (on PROOF 0 is passed).

   TString option = GetOption();

   TNamed *out = (TNamed *) fInput->FindObject("PROOF_DONT_PLOT");
   if (out) fPlot = kFALSE;
   out = (TNamed *) fInput->FindObject("PROOF_NO_FRIENDS");
   if (out) fDoFriends = kFALSE;
}

static void ForEachOption( TidyDoc tdoc, OptionFunc OptionPrint )
{
    TidyIterator pos = tidyGetOptionList( tdoc );

    while ( pos )
    {
        TidyOption topt = tidyGetNextOption( tdoc, &pos );
        OptionDesc d;

        GetOption( tdoc, topt, &d );
        (*OptionPrint)( tdoc, topt, &d );
    }
}

void analysis::SlaveBegin(TTree * /*tree*/)
{
   // The SlaveBegin() function is called after the Begin() function.
   // When running with PROOF SlaveBegin() is called on each slave server.
   // The tree argument is deprecated (on PROOF 0 is passed).

   TString option = GetOption();
   h1_vz =  new TH1F("h1_vz","Vertex Z for the proton",100,-5,5);
   h1_E = new TH1F("h1_E","Energy spectrum for the proton",100,0.,2.);

   fOutput->Add(h1_vz);
   fOutput->Add(h1_E);
}

void Tape::Play ()
{
    if (IsInserted() && !IsPlaying())
    {
        g_fPlaying = true;

        // Schedule next edge
        Tape::NextEdge(g_dwCycleCounter);

        // Trigger turbo mode if fast loading is enabled
        if (IsPlaying() && GetOption(turbotape))
            g_nTurbo |= TURBO_TAPE;
    }
}

//gets the number of parameters that follow the specified option
uint32 CCommandLineParser::GetNumParameters(const char* pszOption) const
{
	//get the option
	const COption* pOpt = GetOption(pszOption);

	//see if we got one
	if(pOpt)
	{
		return pOpt->m_nNumParameters;
	}

	//no option found
	return 0;
}

void abcd::Begin(TTree * /*tree*/)
{
   string option = GetOption();
   cout<<"abcd::Begin --> "<<option<<endl;
   string out_file_name = "../plots/"+option;
   string cur_out_file_name = out_file_name+".abcd.plots.root";

   out_file = (TFile*) TFile::Open(cur_out_file_name.c_str(),"RECREATE");
   out_file->cd();

   string muon_d0sig_met = "scat_muon_d0sig_met";
   scat_muon_d0sig_met = new TH2F(muon_d0sig_met.c_str(),muon_d0sig_met.c_str(),35,0,500,25,0,3);
   
}