PUBLIC void mproc_dmp()
{
struct mproc *mp;
int i, n=0;
static int prev_i = 0;
printf("Process manager (PM) process table dump\n");
getsysinfo(PM_PROC_NR, SI_PROC_TAB, mproc);
printf("-process- -nr-pnr-tnr- --pid--ppid--pgrp- -uid-- -gid-- -nice- -flags-------\n");
for (i=prev_i; i<NR_PROCS; i++) {
mp = &mproc[i];
if (mp->mp_pid == 0 && i != PM_PROC_NR) continue;
if (++n > 22) break;
printf("%8.8s %4d%4d%4d %5d %5d %5d ",
mp->mp_name, i, mp->mp_parent, mp->mp_tracer, mp->mp_pid, mproc[mp->mp_parent].mp_pid, mp->mp_procgrp);
printf("%2d(%2d) %2d(%2d) ",
mp->mp_realuid, mp->mp_effuid, mp->mp_realgid, mp->mp_effgid);
printf(" %3d %s ",
mp->mp_nice, flags_str(mp->mp_flags));
printf("\n");
}
if (i >= NR_PROCS) i = 0;
else printf("--more--\r");
prev_i = i;
}
void mproc_dmp()
{
struct mproc *mp;
struct schedproc *schedp;
int i, j, n=0, k=0;
static int prev_i = 0;
static int prev_j = 0;
if (getsysinfo(PM_PROC_NR, SI_PROC_TAB, mproc, sizeof(mproc)) != OK) {
printf("Error obtaining table from PM. Perhaps recompile IS?\n");
return;
}
if(getsysinfo(SCHED_PROC_NR, SI_PROC_TAB, schedproc,sizeof(schedproc)) != OK){
printf("Error obtaining table from SCHED. Perhaps recompile IS?\n");
return;
}
printf("Process manager (PM) process table dump\n");
printf("-process- -nr-pnr-tnr- --pid--ppid--pgrp- -uid-- -gid-- -nice- -flags-------\n");
for (i=prev_i; i<NR_PROCS; i++) {
mp = &mproc[i];
if (mp->mp_pid == 0 && i != PM_PROC_NR) continue;
if (++n > 10) break;
printf("%8.8s %d %d %3d %4d %4d %5d ",
mp->mp_name, i, mp->mp_scheduler, mp->mp_endpoint, mp->mp_pid, mproc[mp->mp_parent].mp_pid, mp->mp_procgrp);
printf("%2d(%2d) %2d(%2d) ",
mp->mp_realuid, mp->mp_effuid, mp->mp_realgid, mp->mp_effgid);
printf(" %3d %s ",
mp->mp_nice, flags_str(mp->mp_flags));
printf("\n");
}
printf("Proc\t ParentID\t Counter\t Period\t OnePeriod\t Orig Quantum\n");
for(j=prev_j; j < NR_PROCS; j++){
schedp = &schedproc[j];
if(schedp->period_counter == 0) continue;
if (++k > 11) break;
printf("%d\t %d\t\t %6d\t\t %5u\t %7u\t %10u \n",
schedp->endpoint,schedp->parent,schedp->period_counter,schedp->dyn_period,schedp->curr_periods[0],schedp->orig_quantum);
}
if (i >= NR_PROCS) i = 0;
else printf("--more--\r");
prev_i = i;
if (j >= NR_PROCS) j = 0;
else printf("j at: %d" ,j);
prev_j = j;
}
int main( int argc, char* argv[]) {
if( argc!=2 && argc!=3 && argc!=4 ) {
std::cout << "USAGE: ./do2ndLevel_TMVA [dataset] [inputfile=""] [flags=""]" << std::endl;
exit(31);
}
std::string dataset(argv[1]);
Ntp1Analyzer_TMVA* na;
std::string flags = "";
if( argc<4 ) {
na = new Ntp1Analyzer_TMVA(dataset, "BESTZ");
} else {
std::string flags_str(argv[3]);
flags = flags_str;
na = new Ntp1Analyzer_TMVA(dataset, "BESTZ", flags);
}
//na->SetPresel(400);
//na->SetPresel(500);
//na->AddRequiredTrigger( "HLT_Ele15_LW_L1R" );
//na->AddRequiredTrigger( "HLT_Mu9" );
//na->AddRequiredTrigger( "HLT_Mu15" );
if( argc==2 ) {
na->LoadInput();
} else {
std::string inputfile(argv[2]);
na->LoadInputFromFile(inputfile.c_str());
}
na->Loop();
delete na;
return 0;
}
/* if_info state machine transitions caused by interface flag changes (edge triggered) */
void
ifsm_flagchange(struct if_info *info, unsigned int newflags)
{
unsigned int changed = (info->flags ^ newflags) & (IFF_RUNNING | IFF_UP);
if (changed == 0)
return;
char buf1[512], buf2[512];
do_log(LOG_INFO, "%s: state %s flags 0x%08x %s -> 0x%08x %s", info->name,
statename(info->state),
info->flags, flags_str(buf1, info->flags),
newflags, flags_str(buf2, newflags));
/* XXX put interface state-change rate limiting here */
if (0 /* flapping */) {
info->state = ST_INSANE;
}
if (changed & IFF_UP) {
if (newflags & IFF_UP) {
switch(info->state) {
case ST_DOWN:
info->state = ST_INACTIVE;
break;
case ST_PROBING:
info->state = ST_PROBING_UP;
break;
default:
do_log(LOG_ERR, "%s: unexpected state %s for UP", info->name, statename(info->state));
exit(1);
}
} else {
/* interface went down */
switch(info->state) {
case ST_OUTING:
/* went down during an OUT script - OK */
info->state = ST_DOWNANDOUT;
break;
case ST_DOWN:
/* already down */
break;
case ST_PROBING:
/* already probing - don't do anything rash */
break;
case ST_PROBING_UP:
/* well, we were up, but now we're not */
info->state = ST_PROBING;
break;
default:
/* All other states: kill off any scripts currently
running, and go into the PROBING state, attempting
to bring it up */
kill_script(info->worker);
info->state = ST_PROBING;
info->worker = run_netplug_bg(info->name, "probe");
}
}
}
if (changed & IFF_RUNNING) {
switch(info->state) {
case ST_INACTIVE:
assert(!(info->flags & IFF_RUNNING));
assert(info->worker == -1);
info->worker = run_netplug_bg(info->name, "in");
info->state = ST_INNING;
break;
case ST_INNING:
assert(info->flags & IFF_RUNNING);
info->state = ST_WAIT_IN;
break;
case ST_WAIT_IN:
/* unaffected by interface flag changing */
break;
case ST_ACTIVE:
assert(info->flags & IFF_RUNNING);
assert(info->worker == -1);
info->worker = run_netplug_bg(info->name, "out");
info->state = ST_OUTING;
break;
case ST_OUTING:
/* always go to INACTIVE regardless of flag state */
break;
case ST_PROBING:
case ST_PROBING_UP:
/* ignore running state */
break;
case ST_INSANE:
/* stay insane until there's been quiet for a while, then
down interface and switch to ST_DOWN */
break;
case ST_DOWN:
case ST_DOWNANDOUT:
/* badness: somehow interface became RUNNING without being
UP - ignore it */
break;
}
}
do_log(LOG_DEBUG, "%s: moved to state %s; worker %d",
info->name, statename(info->state), info->worker);
info->flags = newflags;
info->lastchange = time(0);
}
int main( int argc, char* argv[] ) {
if( argc!=4 && argc!=5 && argc!=6 ) {
std::cout << "USAGE: ./merge_and_setWeights_PhotonJet [dataset] [recoType] [jetAlgo] [analyzerType=\"PhotonJet\"] [flags=\"\"]" << std::endl;
exit(917);
}
std::string dataset = argv[1];
std::string recoType = argv[2];
std::string jetAlgo = argv[3];
std::string analyzerType="PhotonJet";
if( argc==5 ) {
std::string analyzerType_str(argv[4]);
analyzerType = analyzerType_str;
}
std::string flags="";
if( argc==6 ) {
std::string flags_str(argv[5]);
flags = flags_str;
}
std::string algoName = recoType+jetAlgo;
if( recoType=="calo") algoName=jetAlgo;
if( recoType=="jpt" && jetAlgo=="akt5" ) algoName="jptak5";
if( recoType=="jpt" && jetAlgo=="akt7" ) algoName="jptak7";
tree = new TChain("jetTree");
EventsAndLumi evlu;
evlu = addInput( analyzerType, dataset, algoName, flags );
float weight = getWeight( dataset, evlu.nTotalEvents );
// and now set the weights
tree->SetBranchStatus( "eventWeight", 0 );
Float_t ptPhotReco;
tree->SetBranchAddress( "ptPhotReco", &ptPhotReco );
std::string outfilename;
if( flags!="" )
outfilename = analyzerType + "_2ndLevelTreeW_"+dataset+"_"+algoName+"_"+flags+".root";
else
outfilename = analyzerType + "_2ndLevelTreeW_"+dataset+"_"+algoName+".root";
TFile* outfile = new TFile(outfilename.c_str(), "recreate");
outfile->cd();
TH1F* h1_lumi = new TH1F("lumi", "", 1, 0., 1.);
h1_lumi->SetBinContent(1, evlu.totalLumi);
TTree* newTree = tree->CloneTree(0);
newTree->SetMaxTreeSize(100000000000ULL); //setting max tree size to 100 GB
Float_t newWeight;
newTree->Branch( "eventWeight", &newWeight, "newWeight/F" );
int nentries = tree->GetEntries();
for( unsigned ientry = 0; ientry<nentries; ++ientry ) {
tree->GetEntry(ientry);
if( (ientry % 100000) ==0 ) std::cout << "Entry: " << ientry << " /" << nentries << std::endl;
newWeight = weight;
if( flags=="GENJETS" && h1_eff_vs_pt!=0 ) {
Int_t iBin = h1_eff_vs_pt->FindBin( ptPhotReco );
newWeight *= h1_eff_vs_pt->GetBinContent(iBin);
}
newTree->Fill();
} //for entries
h1_lumi->Write();
newTree->Write();
outfile->Write();
if( h1_eff_vs_pt!= 0 )
h1_eff_vs_pt->Write();
outfile->Close();
return 0;
}
int main(int argc, char* argv[]) {
if (argc != 7 && argc != 8) {
std::cout << "USAGE: ./draw_vs_npv [data_dataset] [mc_SIGNAL_dataset] [mc_BG_dataset] [recoType] [jetAlgo] [norm ('LUMI' or 'SHAPE')] [flags=\"\"]" << std::endl;
exit(23);
}
gROOT->SetBatch();
std::string data_dataset(argv[1]);
std::string mc_photonjet(argv[2]);
std::string mc_QCD(argv[3]);
std::string recoType(argv[4]);
std::string jetAlgo(argv[5]);
std::string norm(argv[6]);
if (norm != "LUMI" && norm != "SHAPE") {
std::cout << "'" << norm << "' normalization not implemented yet." << std::endl;
std::cout << "Only 'LUMI' and 'SHAPE' currently supported." << std::endl;
std::cout << "Exiting." << std::endl;
exit(9811);
}
std::string flags = "";
if (argc == 8) {
std::string flags_str(argv[7]);
flags = flags_str;
}
std::string algoType;
if (recoType == "calo") {
algoType = jetAlgo;
} else {
algoType = recoType + jetAlgo;
}
if (recoType == "jpt" && jetAlgo == "akt4") {
algoType = "jptak4";
}
jetAlgo = (jetAlgo == "ak4") ? "AK4" : "AK8";
recoType = (recoType == "pf") ? "PFlow" : "Calo";
std::string postFix = recoType + jetAlgo;
postFix += "chs";
//Float_t etamax = 3.;
//bool sameEvents = false; //until njets histos have no overflows... or maybe use GetEntries instead of integral?
drawBase* db = new drawBase("PhotonJet", recoType, jetAlgo, OUTPUT_GRAPHS);
db->set_pdf_aussi((bool)false);
db->set_flags(flags);
db->set_isCMSArticle(false);
std::cout << "flags set." << std::endl;
TString dataFileName;
if (flags.length() > 0) {
dataFileName = TString::Format("PhotonJet_%s_%s_%s.root", data_dataset.c_str(), postFix.c_str(), flags.c_str());
} else {
dataFileName = TString::Format("PhotonJet_%s_%s.root", data_dataset.c_str(), postFix.c_str());
}
TFile* dataFile = TFile::Open(dataFileName);
if (dataFile) {
std::cout << "Opened data file '" << dataFileName << "'." << std::endl;
db->add_dataFile(dataFile, data_dataset);
}
TString mc1FileName;
if (flags.length() > 0) {
mc1FileName = TString::Format("PhotonJet_%s_%s_%s.root", mc_photonjet.c_str(), postFix.c_str(), flags.c_str());
} else {
mc1FileName = TString::Format("PhotonJet_%s_%s.root", mc_photonjet.c_str(), postFix.c_str());
}
TFile* mcPhotonJetFile = TFile::Open(mc1FileName);
std::cout << "Opened mc file '" << mc1FileName << "'." << std::endl;
if (mcPhotonJetFile) {
db->add_mcFile(mcPhotonJetFile, mc_photonjet, "#gamma + jets MC", BALANCING);
}
if (mc_QCD != "") {
TString mc2FileName;
if (flags.length() > 0) {
mc2FileName = TString::Format("PhotonJet_%s_%s_%s.root", mc_QCD.c_str(), postFix.c_str(), flags.c_str());
} else {
mc2FileName = TString::Format("PhotonJet_%s_%s.root", mc_QCD.c_str(), postFix.c_str());
}
TFile* mcQCDFile = TFile::Open(mc2FileName);
std::cout << "Opened mc file '" << mc2FileName << "'." << std::endl;
if (mcQCDFile && mc_QCD != mc_photonjet) {
db->add_mcFile(mcQCDFile, mc_QCD, "QCD MC", MPF);
}
}
// MC should already be normalized to a lumi of 1 pb-1
// Read luminosity
double dLumi = 1e6;
if (dataFile) {
TParameter<double>* lumi = static_cast<TParameter<double>*>(dataFile->Get("analysis/luminosity"));
dLumi = lumi->GetVal();
}
std::cout<< "Lumi "<< dLumi << std::endl;
// db->set_lumi(dLumi * 1e-6);
db->set_lumi(dLumi);
if (norm == "LUMI") {
db->set_lumiNormalization();
} else {
db->set_shapeNormalization();
}
db->setFolder("analysis");
std::string outputDir = "PhotonJetPlots_" + db->get_fullSuffix() + "/vs_npv";
db->set_outputdir(outputDir);
bool log = true;
gErrorIgnoreLevel = kWarning;
db->setOutputGraphs(OUTPUT_GRAPHS);
VertexBinning vertexBinning;
std::vector<std::pair<int, int> > vertexBins = vertexBinning.getBinning();
EtaBinning etaBinning;
size_t etaBinningSize = etaBinning.size();
db->set_rebin(2);
db->setFolder("analysis/vertex");
for (size_t i = 0; i < etaBinningSize; i++) {
db->set_legendTitle(etaBinning.getBinTitle(i));
TString responseName = TString::Format("resp_balancing_%s", etaBinning.getBinName(i).c_str());
db->drawHisto_vs_vertex(vertexBins, responseName.Data(), "Balancing Response", "", "Events", log);
// Raw jets
//responseName = TString::Format("resp_balancing_raw_%s", etaBinning.getBinName(i).c_str());
//db->drawHisto_vs_vertex(ptBins, responseName.Data(), "Balancing Response (raw jets)", "", "Events", log);
responseName = TString::Format("resp_mpf_%s", etaBinning.getBinName(i).c_str());
db->drawHisto_vs_vertex(vertexBins, responseName.Data(), "MPF Response", "", "Events", log);
// Raw jets
//responseName = TString::Format("resp_mpf_raw_%s", etaBinning.getBinName(i).c_str());
//db->drawHisto_vs_vertex(ptBins, responseName.Data(), "MPF Response (raw ME_{T})", "", "Events", log);
}
// Special case eta < 1.3
db->set_legendTitle("|#eta| < 1.3");
db->drawHisto_vs_vertex(vertexBins, "resp_balancing_eta0013", "Balancing Response", "", "Events", log);
//db->drawHisto_vs_pt(ptBins, "resp_balancing_raw_eta013", "Balancing Response (raw jets)", "", "Events", log);
db->drawHisto_vs_vertex(vertexBins, "resp_mpf_eta0013", "MPF Response", "", "Events", log);
//db->drawHisto_vs_vertex(ptBins, "resp_mpf_raw_eta013", "MPF Response (raw ME_{T})", "", "Events", log);
delete db;
db = NULL;
return 0;
}
