TEST_F(AnalysisFixture, DataPoint_JSONSerialization_PreRun_Roundtrip) {
Analysis analysis = analysis1(PreRun);
// Retrieve data point
ASSERT_FALSE(analysis.dataPoints().empty());
DataPoint dataPoint = analysis.dataPoints()[0];
// Serialize data point
std::string json = dataPoint.toJSON();
EXPECT_FALSE(json.empty());
// Deserialize and check results
AnalysisJSONLoadResult loadResult = loadJSON(json);
ASSERT_TRUE(loadResult.analysisObject);
ASSERT_TRUE(loadResult.analysisObject->optionalCast<DataPoint>());
DataPoint copy = loadResult.analysisObject->cast<DataPoint>();
EXPECT_EQ(json,copy.toJSON());
// Save data point
openstudio::path p = toPath("AnalysisFixtureData/data_point_pre_run.json");
EXPECT_TRUE(dataPoint.saveJSON(p,true));
// Load and check results
loadResult = loadJSON(json);
ASSERT_TRUE(loadResult.analysisObject);
ASSERT_TRUE(loadResult.analysisObject->optionalCast<DataPoint>());
copy = loadResult.analysisObject->cast<DataPoint>();
EXPECT_EQ(json,copy.toJSON());
}
list<Analysis *> * HfstAnalyzer::analyze(const char * word, bool fullMorphology) {
//cerr << "HfstAnalyzer::analyze (" << string(word) << ")" << endl;
size_t wlen = strlen(word);
if (wlen > LIBVOIKKO_MAX_WORD_CHARS) {
return new list<Analysis *>();
}
list<Analysis *> * analysisList = new list<Analysis *>();
/* I know this is the wrong thing, but going to do it anyway */
std::string str(word);
char * writable = new char[str.size() + 1];
std::copy(str.begin(), str.end(), writable);
writable[str.size()] = '\0';
hfst_ospell::AnalysisQueue q = t->lookup(writable);
while(q.size() > 0) {
hfst_ospell::StringWeightPair pair = q.top();
string analysis = pair.first;
string tags = analysis.substr(analysis.find("+"),analysis.length()-1);
Analysis * a = new Analysis();
if (fullMorphology) {
string lemma = analysis.substr(0,analysis.find("+"));
a->addAttribute(Analysis::Key::BASEFORM, StringUtils::ucs4FromUtf8(lemma.c_str()));
}
a->addAttribute(Analysis::Key::FSTOUTPUT, StringUtils::ucs4FromUtf8(tags.c_str()));
analysisList->push_back(a);
q.pop();
}
return analysisList;
}
void UdpAnalysis::analyzeProtocol(ProtocolStack &pstack, size_t *bytes)
{
if(_bufsize < sizeof(_udphdr))
{
bzero(&_udphdr, sizeof(_udphdr));
return;
}
memcpy(&_udphdr, _buffer, sizeof(_udphdr));
_udphdr.source = ntohs(_udphdr.source);
_udphdr.dest = ntohs(_udphdr.dest);
_udphdr.len = ntohs(_udphdr.len);
_udphdr.check = ntohs(_udphdr.check);
if(bytes != NULL)
*bytes += _udphdr.len;
pstack.push_back(this);
int port = _udphdr.source < _udphdr.dest ? _udphdr.source:_udphdr.dest;
Analysis *child = _getChild(port);
if(child != NULL)
{
child->setBuffer(_buffer + 8, _bufsize - 8);
child->analyzeProtocol(pstack, NULL);
}
}
void MainWindow::saveSelected(const QString &filename)
{
if (_analyses->count() > 0)
{
QWebElement element = ui->webViewResults->page()->mainFrame()->documentElement();
QString qHTML = element.toOuterXml();
_package->analysesHTML = fq(qHTML);
Json::Value analysesData = Json::arrayValue;
for (Analyses::iterator itr = _analyses->begin(); itr != _analyses->end(); itr++)
{
Analysis *analysis = *itr;
if (analysis != NULL && analysis->visible())
{
Json::Value analysisData = analysis->asJSON();
analysisData["options"] = analysis->options()->asJSON();
analysesData.append(analysisData);
}
}
_package->analysesData = analysesData;
_package->hasAnalyses = true;
}
_loader.save(filename, _package);
_alert->show();
}
void Engine::receiveMessages(int timeout)
{
string data;
if (_channel->receive(data, timeout))
{
Value jsonRequest;
Reader r;
r.parse(data, jsonRequest, false);
string analysisName = jsonRequest.get("name", nullValue).asString();
int id = jsonRequest.get("id", -1).asInt();
bool run = jsonRequest.get("perform", "run").asString() == "run";
Value jsonOptions = jsonRequest.get("options", nullValue);
if (_currentAnalysis != NULL && _currentAnalysis->id() == id)
{
_currentAnalysis->options()->set(jsonOptions);
if (run)
_currentAnalysis->setStatus(Analysis::Running);
else
_currentAnalysis->setStatus(Analysis::Empty);
}
else if (_nextAnalysis != NULL && _nextAnalysis->id() == id)
{
_nextAnalysis->options()->set(jsonOptions);
if (run)
_nextAnalysis->setStatus(Analysis::Running);
else
_nextAnalysis->setStatus(Analysis::Empty);
}
else
{
Analysis *analysis = AnalysisLoader::load(id, analysisName);
analysis->options()->set(jsonOptions);
if (run)
analysis->setStatus(Analysis::Running);
if (_dataSet == NULL)
{
managed_shared_memory *mem = SharedMemory::get();
_dataSet = mem->find<DataSet>(boost::interprocess::unique_instance).first;
_R.setDataSet(_dataSet);
}
analysis->setDataSet(_dataSet);
analysis->setRInterface(&_R);
analysis->resultsChanged.connect(boost::bind(&Engine::analysisResultsChanged, this, _1));
if (_nextAnalysis != NULL)
delete _nextAnalysis;
_nextAnalysis = analysis;
if (_currentAnalysis != NULL)
_currentAnalysis->setStatus(Analysis::Aborted);
}
}
}
void Analyses::clear()
{
for (Analyses::iterator itr = this->begin(); itr != this->end(); itr++)
{
Analysis *analysis = *itr;
if (analysis->status() != Analysis::Complete)
analysis->setStatus(Analysis::Aborted);
}
}
int main( int argc, char **argv )
{
Analysis *scmanal = new Analysis( 1, 0, 3, "AMPLITUDE DURATION RATE", argc, argv );
double amplitude = atof( argv[ 2 ] );
double duration = atof( argv[ 3 ] );
double rate = atof( argv[ 4 ] );
char output_comment[ 256 ];
snprintf( output_comment, 256, "(%f) * noise", amplitude );
scmanal->set_comment( 0, output_comment );
scmanal->set_type( 0, TIME_DOMAIN );
scmanal->set_begin( 0, 0 );
scmanal->set_end( 0, duration );
scmanal->set_compl_begin( 0, 0 );
scmanal->set_compl_end( 0, rate / 2 );
size_t length = int(duration * rate);
scmanal->make_outputs( length );
double *output = scmanal->get_file( 0 );
for ( uint i = 0; i < length; i++ ) {
output[ i ] = 2*amplitude*((rand()/(RAND_MAX+1.0))-.5);
}
delete scmanal;
}
TEST_F(AnalysisDriverFixture,RuntimeBehavior_StopAndRestartDakotaAnalysis) {
// RETRIEVE PROBLEM
Problem problem = retrieveProblem("SimpleHistogramBinUQ",true,false);
// DEFINE SEED
Model model = model::exampleModel();
openstudio::path p = toPath("./example.osm");
model.save(p,true);
FileReference seedModel(p);
// CREATE ANALYSIS
SamplingAlgorithmOptions algOptions;
algOptions.setSamples(10);
Analysis analysis("Stop and Restart Dakota Analysis",
problem,
SamplingAlgorithm(algOptions),
seedModel);
// RUN ANALYSIS
if (!dakotaExePath().empty()) {
ProjectDatabase database = getCleanDatabase("StopAndRestartDakotaAnalysis");
AnalysisDriver analysisDriver(database);
AnalysisRunOptions runOptions = standardRunOptions(analysisDriver.database().path().parent_path());
StopWatcher watcher(analysisDriver);
watcher.watch(analysis.uuid());
CurrentAnalysis currentAnalysis = analysisDriver.run(analysis,runOptions);
analysisDriver.waitForFinished();
EXPECT_FALSE(analysisDriver.isRunning());
// check conditions afterward
boost::optional<runmanager::JobErrors> jobErrors = currentAnalysis.dakotaJobErrors();
ASSERT_TRUE(jobErrors);
EXPECT_FALSE(jobErrors->errors().empty());
EXPECT_FALSE(currentAnalysis.analysis().dataPoints().empty());
EXPECT_FALSE(currentAnalysis.analysis().dataPointsToQueue().empty());
EXPECT_FALSE(currentAnalysis.analysis().completeDataPoints().empty());
EXPECT_FALSE(currentAnalysis.analysis().successfulDataPoints().empty());
EXPECT_TRUE(currentAnalysis.analysis().failedDataPoints().empty());
EXPECT_FALSE(currentAnalysis.analysis().algorithm()->isComplete());
EXPECT_FALSE(currentAnalysis.analysis().algorithm()->failed());
EXPECT_EQ(0u,analysisDriver.currentAnalyses().size());
LOG(Debug,"After initial stop, there are " << currentAnalysis.analysis().dataPoints().size()
<< " data points, of which " << currentAnalysis.analysis().completeDataPoints().size()
<< " are complete.");
// try to restart from database contents
Analysis analysis = AnalysisRecord::getAnalysisRecords(database)[0].analysis();
ASSERT_TRUE(analysis.algorithm());
EXPECT_FALSE(analysis.algorithm()->isComplete());
EXPECT_FALSE(analysis.algorithm()->failed());
currentAnalysis = analysisDriver.run(analysis,runOptions);
analysisDriver.waitForFinished();
EXPECT_EQ(10u,analysis.dataPoints().size());
EXPECT_EQ(0u,analysis.dataPointsToQueue().size());
EXPECT_EQ(10u,analysis.completeDataPoints().size());
EXPECT_EQ(10u,analysis.successfulDataPoints().size());
EXPECT_EQ(0u,analysis.failedDataPoints().size());
}
}
bool Analysis::operator==(const Analysis &analysis) const
{
if (GetState()!=analysis.GetState())
return false;
if (m_negated!=analysis.m_negated)
return false;
if (GetType()!=analysis.GetType())
return false;
else
return Equals(&analysis);
}
void EngineSync::sendMessages()
{
#ifdef QT_DEBUG
std::cout << "send messages\n";
std::cout.flush();
#endif
for (int i = 0; i < _analysesInProgress.size(); i++)
{
Analysis *analysis = _analysesInProgress[i];
if (analysis != NULL && analysis->status() == Analysis::Empty)
sendToProcess(i, analysis);
}
for (Analyses::iterator itr = _analyses->begin(); itr != _analyses->end(); itr++)
{
Analysis *analysis = *itr;
if (analysis->status() == Analysis::Empty)
{
bool sent = false;
for (int i = 0; i < _analysesInProgress.size(); i++)
{
if (_analysesInProgress[i] == NULL)
{
sendToProcess(i, analysis);
sent = true;
break;
}
}
if (sent == false) // no free processes left
return;
}
else if (analysis->status() == Analysis::Inited)
{
#ifndef QT_DEBUG
for (int i = 1; i < _analysesInProgress.size(); i++) // don't perform 'runs' on process 0, only inits.
#else
for (int i = 0; i < _analysesInProgress.size(); i++)
#endif
{
if (_analysesInProgress[i] == NULL)
{
sendToProcess(i, analysis);
break;
}
}
}
}
}
TEST_F(ProjectFixture,Profile_ProblemSave) {
Analysis analysis = getAnalysisToRun(100,0);
// time the process of saving to database
ptime start = microsec_clock::local_time();
ProjectDatabase db = getCleanDatabase(toPath("./ProblemSave"));
ASSERT_TRUE(db.startTransaction());
ProblemRecord record = ProblemRecord::factoryFromProblem(analysis.problem(),db);
db.save();
ASSERT_TRUE(db.commitTransaction());
time_duration saveTime = microsec_clock::local_time() - start;
std::cout << "Time: " << to_simple_string(saveTime) << std::endl;
}
void runPixelTreeMaker(Bool_t doMC = 0,
const char *files = 0,
const char *outfile = 0,
UInt_t nev = 0,
Float_t SDRelFrac = 1.)
{
gDebugMask = Debug::kAnalysis;
gDebugLevel = 1;
gErrorIgnoreLevel = kInfo;
// setup analysis object
Analysis *ana = new Analysis;
ana->SetUseHLT(1);
if (nev>0)
ana->SetProcessNEvents(nev);
TString ofname(gSystem->Getenv("MIT_OUTPUTFILE"));
if (!ofname.IsNull())
ana->SetOutputName(ofname);
if (files) {
TString dummy(files);
TString suffix(dummy(dummy.Length()-4,dummy.Length()));
if (suffix.CompareTo("root")==0)
ana->AddFile(files);
else
ana->AddFiles(files);
}
HLTMod *hmod = new HLTMod;
hmod->SetPrintTable(1);
ana->AddSuperModule(hmod);
// setup modules
PixelsMakerMod *mod = new PixelsMakerMod;
mod->SetIsMC(doMC);
mod->AddVertexName("Pixel3Vertexes");
mod->AddVertexName("TrackletVertexes");
mod->AddVertexName("ClusterVertexes");
mod->AddVertexName("PixelVertexes");
mod->AddVertexName("PrimaryVertexes");
mod->AddVertexName("PrimaryVertexesBeamSpot");
// - diffractive study -
mod->SetUseHfOnly(true);
mod->SetSDRelFrac(SDRelFrac);
if (outfile)
mod->SetFileName(Form("%s_SDRelFrac%.1f.root",outfile,SDRelFrac));
else
mod->SetFileName("pixeltree.root");
ana->AddSuperModule(mod);
// run the analysis after successful initialisation
ana->Run(!gROOT->IsBatch());
}
Str2VarMap getJpsiPars(TString type, TCut cut, TFile * file)
{
string datafilename = "/afs/cern.ch/work/p/pluca/weighted/Lmumu/candLb.root";
string candfilename = "/afs/cern.ch/work/p/pluca/weighted/Lmumu/candLb_MC.root";
TFile * MCFile = TFile::Open(candfilename.c_str());
TTree * BdJpsiKSTree = (TTree *)MCFile->Get("candBdJpsiKS");
file->cd();
RooRealVar * vMuMu = new RooRealVar("Lb_MassConsLambda","Lb_MassConsLambda",5620.,5350.,6000.);
Analysis * anaLbMuMu_MC = new Analysis("Lb2Lmumu_"+type+"_MC","Lb","candLb2Lmumu",candfilename,vMuMu,&CutsDef::cutMuMu);
RooRealVar * vJpsi = new RooRealVar("Lb_MassConsJpsiLambda","Lb_MassConsJpsiLambda",5620.,5250.,6000.);
Analysis * anaLbJpsi_default = new Analysis("Jpsi_default","Lb","candLb2JpsiL",datafilename,vJpsi,&CutsDef::cutJpsi);
string model = "DCB_Sn";
string optionsjpsi = "-ANDpulls-log-stdAxis-quiet-XM(#Lambda#mu#mu) (MeV/c^{2})-noCost-nochi2";
string optionsmumu = "-stdAxis-quiet-XM(#Lambda#mu#mu) (MeV/c^{2})-noCost-nochi2";
anaLbMuMu_MC->SetSignal((model+"-s[9]-s2[30]").c_str());
anaLbMuMu_MC->Initialize("");
anaLbMuMu_MC->Fit(5400.,5750.,200,true,"-stdAxis-XM(#Lambda#mu#mu) (MeV/c^{2})-noCost-nochi2",CutsDef::mumuTrueID+cut);
Str2VarMap MCpars = anaLbMuMu_MC->GetSigParams();
Analysis * KS = new Analysis("KS_bkg","Lb",BdJpsiKSTree,vJpsi,"DCB_OST","","-namepar");
KS->Fit(5300.,6000.,150,true,"-noPlot-quiet");
Str2VarMap pars = KS->GetSigParams();
RooRealVar * m_shift = new RooRealVar("m_shift","shift",0.,-5.,5.);
setConstant(&pars);
ModifyPars(&pars,"m",m_shift,"-shift");
string jpsimodel = model+"-Xn"+Form("[%f]",MCpars["n"]->getVal());
jpsimodel += (string)"-s[7,1,12]";//+Form("[%f]",MCpars["s"]->getVal());
jpsimodel += (string)"-s2[15,8,30]";//+Form("[%f,]",MCpars["s2"]->getVal());
jpsimodel += (string)"-a"+Form("[%f]",MCpars["a"]->getVal());
jpsimodel += (string)"-a2"+Form("[%f]",MCpars["a2"]->getVal());
jpsimodel += (string)"-f"+Form("[%f]",MCpars["f"]->getVal());
anaLbJpsi_default->SetSignal(jpsimodel.c_str());
RooRealVar * nKSjpsi = new RooRealVar("nKSjpsi","nKSjpsi",2.e3,0,1.e4);
anaLbJpsi_default->addBkgComponent("JpsiKS","DCB_OST",nKSjpsi,"",pars);
//anaLbJpsi_default->addBkgComponent("BuKst",BuKstmumuTree,350.);
anaLbJpsi_default->Initialize();
anaLbJpsi_default->Fit(5300.,6000.,200,true,optionsjpsi,cut);
Str2VarMap jpsiSigpars = anaLbJpsi_default->GetSigParams();
setConstant(&jpsiSigpars);
RooRealVar * factor = new RooRealVar("factor","factor",1.,0.5,3.);
ModifyPars(&jpsiSigpars,"s",factor);
ModifyPars(&jpsiSigpars,"s2",factor);
return jpsiSigpars;
}
void EngineSync::process()
{
for (int i = 0; i < _channels.size(); i++)
{
Analysis *analysis = _analysesInProgress[i];
if (analysis == NULL)
continue;
IPCChannel *channel = _channels[i];
string data;
if (channel->receive(data))
{
#ifdef QT_DEBUG
std::cout << "message received\n";
std::cout << data << "\n";
std::cout.flush();
#endif
Json::Reader reader;
Json::Value json;
reader.parse(data, json);
//int id = json.get("id", -1).asInt();
//bool init = json.get("perform", "init").asString() == "init";
Json::Value results = json.get("results", Json::nullValue);
string status = json.get("status", "error").asString();
if (analysis->status() == Analysis::Initing)
{
analysis->setStatus(Analysis::Inited);
analysis->setResults(results);
_analysesInProgress[i] = NULL;
sendMessages();
}
else if (analysis->status() == Analysis::Running)
{
if (status == "complete")
{
analysis->setStatus(Analysis::Complete);
analysis->setResults(results);
_analysesInProgress[i] = NULL;
sendMessages();
}
else
{
analysis->setResults(results);
}
}
else
{
sendMessages();
}
}
}
}
string AsteroidTracker::nextCommand(double currentTime) {
Analysis a;
string the_big_answer;
vector<_link> links, rankedLinks;
vector<int> targetList;
vector<double> timesToRelocate;
int commandListSize;
nextCommandTime = currentTime;
while ((!commandDeckLoaded) && (nextCommandTime < SIMULATION_TIME)) {
links.clear();
rankedLinks.clear();
targetList.clear();
timesToRelocate.clear();
links = generateLinks(nextCommandTime);
rankedLinks = rankLinks(links);
targetList = generateTargetLinks(rankedLinks);
timesToRelocate = generateTimesToRelocate(targetList, nextCommandTime);
double maxRelocateTime = a.max(timesToRelocate);
relocateAntennas(targetList, maxRelocateTime, nextCommandTime);
double beamTime = activateAntennas(nextCommandTime);
monitorAsteroids(beamTime, nextCommandTime);
}
commandDeckLoaded = true;
if (!antennasRetired) { // set a trap to prevent the deck from being overloaded
retireAntennas();
antennasRetired = true;
commandListSize = commandList.size();
}
// fill the output returned with the command note.
if (commandDeckLoaded) { // Added to v2
if (commandNumber < commandListSize) {
the_big_answer = commandList.at(commandNumber).commandNote;
}
commandNumber++;
}
// evaluate all links to determine the best candidate
cout << "Number of Antennas: " << numberOfAntennas << endl;
cout << "Number of Asteroids: " << numberOfAsteroids << endl;
cout << "Number of Commands: " << commandList.size() << endl;
return the_big_answer;
}
/** Add specified analysis to the analysis list with given args and
* DataSetList.
*/
int AnalysisList::AddAnalysis(DispatchObject::DispatchAllocatorType Alloc, ArgList& argIn,
DataSetList* DSLin, DataFileList* DFLin)
{
Analysis* ana = (Analysis*)Alloc();
// Attempt to set up analysis
if (ana->Setup( argIn, DSLin, DFLin, debug_) != Analysis::OK) {
mprinterr("Error: Could not setup analysis [%s]\n", argIn.Command());
delete ana;
return 1;
}
analysisList_.push_back( ana );
analysisCmd_.push_back( argIn.ArgLine() );
analysisStatus_.push_back( SETUP );
if (argIn.CheckForMoreArgs()) return 1;
return 0;
}
void analysistest()
{
Analysis a;
CodeBufferInfo o;
CPEFile file;
file.LoadPEFile("mfc.exe");
if (!file.IsPEFile())
{
return ;
}
o.buf = file.VaToPtr(0x4014a0);
for (int i = 0; i < 0x21; ++i)
{
printf("i = %d,%x\r\n",i,((char*)o.buf)[i]);
}
o.addr = 0x4014a0;
o.size = 0x3a;
a.disasm(&o);
}
//--------------------------------------------------------------------------------------------------
void merge(const char *files,
const char *prefix="mergetest",
UInt_t nev=0)
{
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 1;
OutputMod *omod = new OutputMod;
omod->SetFileName(prefix);
omod->Keep("*");
Analysis *ana = new Analysis;
ana->SetSuperModule(omod);
if (nev)
ana->SetProcessNEvents(nev);
ana->AddFile(files);
// run the analysis after successful initialisation
ana->Run(0);
}
Analysis *Analyses::create(string name, int id)
{
Analysis *analysis = AnalysisLoader::load(id, name);
if (_defaults.find(name) != _defaults.end())
{
Json::Value opt = _defaults[name]->options()->asJSON();
analysis->options()->set(opt);
}
while (id >= _analyses.size())
_analyses.push_back(NULL);
_analyses[id] = analysis;
analysis->optionsChanged.connect(boost::bind(&Analyses::analysisOptionsChangedHandler, this, _1));
analysis->resultsChanged.connect(boost::bind(&Analyses::analysisResultsChangedHandler, this, _1));
analysisAdded(analysis);
return analysis;
}
boost::optional<DataPoint> DakotaAlgorithm_Impl::createNextDataPoint(
Analysis& analysis,const DakotaParametersFile& params)
{
OS_ASSERT(analysis.algorithm().get() == getPublicObject<DakotaAlgorithm>());
// TODO: Update iteration counter.
OptionalDataPoint result = analysis.problem().createDataPoint(params,
getPublicObject<DakotaAlgorithm>());
if (result) {
bool added = analysis.addDataPoint(*result);
if (!added) {
// get equivalent point already in analysis
DataPointVector candidates = analysis.getDataPoints(result->variableValues());
OS_ASSERT(candidates.size() == 1u);
result = candidates[0];
}
std::stringstream ss;
ss << name() << "_" << m_iter;
result->addTag(ss.str());
}
return result;
}
//--------------------------------------------------------------------------------------------------
void runJetValidation()
{
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 1;
// set up the modules
JetValidationMod *eventSelectionMod = new JetValidationMod;
// set up analysis
Analysis *ana = new Analysis;
ana->SetSuperModule(eventSelectionMod);
TString files = TString("castor:/castor/cern.ch/user/s/sixie/OAKSamples/relval212QCDpt50_80-id6/*.root");
ana->AddFile(files);
ana->SetOutputName("mit-JetValidation-hist.root");
// ana->SetProcessNevents(1000);
// run the analysis after successful initialisation
ana->Run(! gROOT->IsBatch());
}
int main(int argc, char ** argv) {
if (argc != 2+1) {
cout << "wrong number of arguments - usage :" << endl;
cout << argv[0] << " <input txt file> <output file name>" << endl;
return 1;
}
TString txtFile(argv[1]);
TString outputFileName(argv[2]);
cout << "input txt file = " << txtFile << endl;
cout << "output file name = " << outputFileName << endl;
Analysis analysis;
ifstream in;
in.open(txtFile);
while (true) {
TString fileName;
in >> fileName;
if (!in.good()) break;
TFile * f = TFile::Open(fileName);
if(!f->IsOpen()) {
printf("ERROR file %s not found\n", fileName.Data());
return 1;
}
f->Close();
analysis.add(fileName);
}
in.close();
analysis.init();
analysis.loop(outputFileName);
return 0;
}
void runWWAnalysisChain(TString inputfiles, TString outputfileName, TString PlotType, TString JetsName) {
//Trigger
HLTMod *hltmod = new HLTMod;
hltmod->SetPrintTable(kFALSE);
// hltmod->AddTrigger("HLT_IsoMu15");
// hltmod->AddTrigger("HLT_IsoEle15_L1I");
hltmod->AddTrigger("HLT_Mu5");
hltmod->AddTrigger("HLT_Ele10_SW_L1R");
hltmod->SetTrigObjsName("myhltobjs");
//PreSelection
HwwEvtPreSelMod *preSelectionMod = new HwwEvtPreSelMod;
//Object ID and Cleaning Sequence;
MuonIDMod *muonID = new MuonIDMod;
ElectronIDMod *electronID = new ElectronIDMod;
JetIDMod *JetID = new JetIDMod; //default names are IC5
JetID->SetJetName(JetsName); //for SC5 I have to set the names
JetID->SetGoodJetsName(TString("GoodJets"));
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
JetCleaningMod *JetCleaning = new JetCleaningMod; //default names are ok for IC5
JetCleaning->SetGoodJetsName(TString("GoodJets"));
JetCleaning->SetCleanJetsName(TString("CleanJets"));
//Event Selection modules
WWEvtSelMod *eventSelectionMod = new WWEvtSelMod;
eventSelectionMod->SetLoadGenParticles(false);
eventSelectionMod->SetCleanJetsName(TString("CleanJets"));
eventSelectionMod->SetPlotType(PlotType);
eventSelectionMod->SetPrintDebug(false);
//chain modules together
hltmod->Add(preSelectionMod);
preSelectionMod->Add(muonID);
muonID->Add(electronID);
electronID->Add(JetID);
JetID->Add(electronCleaning);
electronCleaning->Add(JetCleaning);
JetCleaning->Add(eventSelectionMod);
// set up analysis
Analysis *ana = new Analysis;
//ana->SetUseHLT(false);
ana->SetKeepHierarchy(kFALSE);
ana->SetSuperModule(preSelectionMod);
ana->AddFile(inputfiles);
ana->SetOutputName(outputfileName.Data());
// run the analysis after successful initialisation
ana->Run(! gROOT->IsBatch());
cout << "HLTMod: Accepted " << hltmod->GetNAccepted()
<< " of " << hltmod->GetNEvents() << " events" << endl;
return;
}
//--------------------------------------------------------------------------------------------------
void runMakeMuonFakeRate()
{
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 1;
// set up the modules
ObjectCleaningMod *objectSelectionMod = new ObjectCleaningMod;
MuonFakeRateAnalysisMod *eventSelectionMod = new MuonFakeRateAnalysisMod;
objectSelectionMod->Add(eventSelectionMod);
objectSelectionMod->SetGoodElectronsName(TString("GoodElectrons"));
objectSelectionMod->SetGoodMuonsName(TString("GoodMuons"));
objectSelectionMod->SetGoodCentralJetsName(TString("GoodCentralJets"));
objectSelectionMod->SetGoodForwardJetsName(TString("GoodForwardJets"));
objectSelectionMod->SetGoodMuonCorrectedMetName(TString("MuonCorrectedMet"));
eventSelectionMod->SetGoodElectronsName(TString("GoodElectrons"));
eventSelectionMod->SetGoodMuonsName(TString("GoodMuons"));
eventSelectionMod->SetGoodCentralJetsName(TString("GoodCentralJets"));
eventSelectionMod->SetGoodForwardJetsName(TString("GoodForwardJets"));
eventSelectionMod->SetGoodMuonCorrectedMetName(TString("MuonCorrectedMet"));
// set up analysis
Analysis *ana = new Analysis;
ana->SetSuperModule(objectSelectionMod);
const char *catalogDir = "/home/mitprod/catalog";
const char *book = "mit/filler/001";
const char *dataset = "qcdem_pt_30_80-id6";
// Catalog *c = new Catalog(catalogDir);
// Dataset *d = c->FindDataset(book,dataset);
// ana->AddDataset(d);
TString slash = "/";
TString castorBase = "castor:/castor/cern.ch/user/s/sixie/";
//TString localBase = "/server/03b/paus";
//TString files = TString("OAKSamples/test/") + dataset + TString("_000_*.root");
//ana->AddFile(castorBase + slash + files );
//TString files = TString("/server/02a/sixie/CMSSW_2_1_5/src/testProd/crab_0_080831_113313/res/") + dataset + TString("_000_*.root");
TString files = TString("/server/04d/sixie/OAKSamples/002/qcdem_pt_30_80-id6/") + dataset + TString("_000_*.root");
ana->AddFile(files);
ana->SetOutputName("mit-MuonFakeRate_QCD-hist.root");
ana->SetProcessNevents(1000000);
// run the analysis after successful initialisation
ana->Run(! gROOT->IsBatch());
}
int main( int argc, char **argv )
{
Analysis *scmanal = new Analysis( 1, 1, 1, "AIFF_OUTPUT", argc, argv );
char *output_aiff_filename = argv[ 2 ];
assert( scmanal->get_type( 0 ) == TIME_DOMAIN );
/* Open AIFF input */
SF_INFO aiff_info;
aiff_info.format = SF_FORMAT_AIFF | SF_FORMAT_PCM_24;
aiff_info.frames = scmanal->get_length( 0 );
aiff_info.samplerate = 2 * (scmanal->get_compl_end( 0 ) - scmanal->get_compl_begin( 0 ));
aiff_info.channels = 2;
aiff_info.sections = 0;
aiff_info.seekable = 0;
SNDFILE *aiff = sf_open( output_aiff_filename, SFM_WRITE, &aiff_info );
if ( aiff == NULL ) {
fprintf( stderr, "sf_open: %s\n", sf_strerror( NULL ) );
exit( 1 );
}
double *file_samples = scmanal->get_file( 0 );
uint length = scmanal->get_length( 0 );
uint overflow_count = 0;
for ( uint i = 0; i < length; i++ ) {
int samples[ 2 ];
if ( fabs( file_samples[ i ] ) >= 1<<23 ) {
// fprintf( stderr, "Warning: Possible overflow at sample %d\n", i );
overflow_count++;
}
samples[ 0 ] = samples[ 1 ] = 256.0 * file_samples[ i ];
assert( sf_writef_int( aiff, samples, 1 ) == 1 );
}
if ( overflow_count ) {
fprintf( stderr, "Warning: %d possible overflows\n", overflow_count );
}
delete scmanal;
assert( sf_close( aiff ) == 0 );
}
void Game::Start(int Round)
{
for(int i=1;i<=Round;i++)
{
double Max=0;
int Luck=0;
Packet RedPacket(PacketMoney,PacketQuota);
GetOrder();
for(int j=1;j<=PacketQuota;j++)
{
double Get=RedPacket.GetMoney();
int Index=Order[j];
Money[Index]+=Get;
}
Luck=Debug.Statistics(Money,PacketMoney);
Money[Luck]-=PacketMoney;
}
}
//--------------------------------------------------------------------------------------------------
void runHLTExample(const char *trigger="HLT_Mu15_v1",
//const char *files = "XX-MITDATASET-XX_000.root",
const char *files = "/castor/cern.ch/user/p/paus/filefi/020/p11-h160ww2l-gf-v1g1-pu/342631BD-F250-E011-9C32-00A0D1EE8B54.root",
Int_t nEvs = 0)
{
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 1;
HLTMod *hltmod = new HLTMod;
hltmod->SetPrintTable(kTRUE);
hltmod->AddTrigger(trigger);
hltmod->SetTrigObjsName("myhltobjs");
HLTExampleMod *hltexmod = new HLTExampleMod;
hltexmod->SetTrigObjsName("myhltobjs");
hltmod->Add(hltexmod);
// set up analysis
Analysis *ana = new Analysis;
if (0) {
hltmod->SetBitsName("HLTBits");
ana->SetHLTTreeName("HLT");
ana->SetHLTObjsName("HLTObjects");
}
if (nEvs)
ana->SetProcessNEvents(nEvs);
ana->SetSuperModule(hltmod);
ana->AddFile(files);
if (gROOT->IsBatch())
ana->SetOutputName("mit-hlt-hist.root");
// run the analysis after successful initialisation
ana->Run(!gROOT->IsBatch());
cout << "HLTMod: Accepted " << hltmod->GetNAccepted()
<< " of " << hltmod->GetNEvents() << " events" << endl;
}
void buildBkgPdfs(double q2min, double q2max, TString name, TCut cut, RooAbsPdf ** bkg, RooAbsPdf ** bkgB, TString model = "Poly2")
{
RooRealVar * cosThetaL = new RooRealVar("cosThetaL","cosThetaL",0.,-1.,1.);
RooRealVar * cosThetaB = new RooRealVar("cosThetaB","cosThetaB",0.,-1.,1.);
TString q2name = ((TString)Form("_q2_%4.2f_%4.2f",q2min,q2max)).ReplaceAll(".","");
string datafile = "/afs/cern.ch/work/p/pluca/weighted/Lmumu/trainingSamples.root";
string treename = "bkgTestSample";
if(q2min == 8 && q2max == 11)
{
q2name = "_jpsi";
datafile = "/afs/cern.ch/work/p/pluca/weighted/Lmumu/Lb2Lmumu_CL_NBweighted.root";
treename = "tree";
}
Analysis * ana = new Analysis("data"+name+q2name,"Lb",treename,datafile);
ana->AddVariable(cosThetaL);
ana->AddVariable(cosThetaB);
ana->AddVariable("J_psi_1S_MM");
ana->AddVariable("Lb_MM");
TCut sideBand = "(Lb_MM > 5690 || Lb_MM < 5550) && weight > 0.8";
if(q2min == 8 && q2max == 11) sideBand = "Lb_MM > 6000 && weight > 0.8 && TMath::Abs(J_psi_1S_MM - 3096.916) < 92.9";
TCut q2cut = (TCut)Form("TMath::Power(J_psi_1S_MM/1000,2) > %e && TMath::Power(J_psi_1S_MM/1000,2) < %e",q2min,q2max);
TCut mycut = sideBand + q2cut + cut;
ana->applyCuts(&mycut);
RooDataSet * data = ana->GetDataSet("-recalc");
if(model=="RooKeyPdf")
{
(*bkg) = new RooKeysPdf("bkg"+name,"bkg"+name,*cosThetaL,*data,RooKeysPdf::MirrorBoth,1);
(*bkgB) = new RooKeysPdf("bkg"+name+"B","bkg"+name+"B",*cosThetaB,*data,RooKeysPdf::MirrorBoth,1);
}
else
{
(*bkg) = stringToPdf(model,"bkg"+name, cosThetaL);
(*bkg)->fitTo(*data,PrintLevel(-1));
fixParams((*bkg),cosThetaL);
(*bkgB) = stringToPdf(model,"bkg"+name+"B", cosThetaB);
(*bkgB)->fitTo(*data,PrintLevel(-1));
fixParams((*bkgB),cosThetaB);
}
}
TEST_F(AnalysisFixture, DataPoint_Selected) {
// Create analysis
Analysis analysis = analysis1(PreRun);
// See how many to queue
unsigned totalToRun = analysis.dataPointsToQueue().size();
ASSERT_LT(0u,totalToRun);
// Turn one off
ASSERT_FALSE(analysis.dataPoints().empty());
EXPECT_EQ(totalToRun,analysis.dataPoints().size());
DataPoint dataPoint = analysis.dataPoints()[0];
dataPoint.setSelected(false);
EXPECT_FALSE(dataPoint.selected());
// Make sure shows up in "ToQueue"
EXPECT_EQ(totalToRun - 1u,analysis.dataPointsToQueue().size());
}
//HDF5转化成raw，geotif
//-o out.tif -i xxx.hdf -d ds1 ds2 //-b ds1<2,1,0> 或者ds1<0> ds2<1> ds3<2>
int main(int argc, char* argv[])
{
try
{
//分析参数
Analysis ana;
ana.SetParam(argc,argv);
ana.Execute();
//处理获取-d指定的数据集
vector<string> vc;
ana.GetConvertedDataSet(vc);
//依次处理每一个数据集
for(int i=0;i<vc.size();++i)
{
cout<<"Convert DataSet:"<<vc[i]<<endl;
string dsFile=ana.GetDataSetFile(vc[i].c_str());
string dsGroup=ana.GetDataSetGroupPath(vc[i].c_str());
if(dsFile.empty()||dsGroup.empty())
{
cout<<"Can not find dataset:"<<vc[i]<<endl;
continue;
}
//格式转化输出
ConvertDataset(dsFile,dsGroup,ana.GetOutputFile());
}
}
catch (std::exception* e)
{
cout<<e->what()<<endl;
}
catch (...)
{
cout<<"Unknow error!"<<endl;
}
#ifdef _DEBUG
system("pause");
#endif
return 0;
}
