TEST_F(SimplePipelineTest, test_simple_pswf_exact)
{
// Config file
std::string configfile(config_path + "fastimg_exact_pswf_config.json");
load_configdata(configfile);
// Execute pipeline based on the loaded configurations
stp::SourceFindImage sfimage = execute_pipeline();
int total_islands = sfimage.islands.size();
ASSERT_EQ(total_islands, 1);
int label_idx = sfimage.islands[0].label_idx;
int sign = sfimage.islands[0].sign;
double extremum_val = sfimage.islands[0].extremum_val;
int extremum_x_idx = sfimage.islands[0].extremum_x_idx;
int extremum_y_idx = sfimage.islands[0].extremum_y_idx;
EXPECT_EQ(label_idx, 1);
EXPECT_EQ(sign, 1);
EXPECT_NEAR(extremum_val, 0.49762858232302537, pipeline_tolerance);
EXPECT_EQ(extremum_x_idx, 824);
EXPECT_EQ(extremum_y_idx, 872);
// Do not compare x_centre and y_centre (moments-fit) because there are differences
// on the number of samples of the island. The difference seems to be caused by
// numeric errors on sigma clip function (the function is not numerically stable).
}
TEST_F(SimplePipelineTest, test_simple_gaussiansinc_oversampling)
{
// Config file
std::string configfile(config_path + "fastimg_oversampling_gaussiansinc_config.json");
load_configdata(configfile);
// Execute pipeline based on the loaded configurations
stp::SourceFindImage sfimage = execute_pipeline();
int total_islands = sfimage.islands.size();
ASSERT_EQ(total_islands, 1);
int label_idx = sfimage.islands[0].label_idx;
int sign = sfimage.islands[0].sign;
double extremum_val = sfimage.islands[0].extremum_val;
int extremum_x_idx = sfimage.islands[0].extremum_x_idx;
int extremum_y_idx = sfimage.islands[0].extremum_y_idx;
double xbar = sfimage.islands[0].moments_fit.x_centre;
double ybar = sfimage.islands[0].moments_fit.y_centre;
EXPECT_EQ(label_idx, 1);
EXPECT_EQ(sign, 1);
EXPECT_NEAR(extremum_val, 0.10973023095014588, pipeline_tolerance);
EXPECT_EQ(extremum_x_idx, 824);
EXPECT_EQ(extremum_y_idx, 872);
EXPECT_NEAR(xbar, 823.363524400699, pipeline_tolerance);
EXPECT_NEAR(ybar, 871.582414171632, pipeline_tolerance);
}
bool CFlashTool::GetVersionInfo(CFlashVersionInfo& versionInfo, std::string filename)
{
std::string versionPath = LOCAL_MOUNT_DIR "/.version";
printf("[CFlashTool] check filename: %s\n", filename.c_str());
if (mountImage(filename)) {
CConfigFile configfile('\t');
bool success =configfile.loadConfig(versionPath);
if (success) {
const char * versionString = configfile.getString( "version", "????????????????").c_str();
printf("[CFlashTool] read version string: %s\n", versionString);
versionInfo.load(versionString);
unmountImage();
return true;
} else {
printf("[CFlashTool] error reading .version\n");
unmountImage();
return false;
}
} else {
printf("[CFlashTool] mount error\n");
unmountImage();
return false;
}
}
/** Write settings to config file. */
void UserConfig::saveConfig()
{
const std::string filename = file_manager->getUserConfigFile(m_filename);
try
{
std::ofstream configfile (filename.c_str(), std::ofstream::out);
configfile << "<?xml version=\"1.0\"?>\n";
configfile << "<stkconfig version=\"" << m_current_config_version
<< "\" >\n\n";
const int paramAmount = all_params.size();
for(int i=0; i<paramAmount; i++)
{
//std::cout << "saving parameter " << i << " to file\n";
all_params[i].write(configfile);
}
configfile << "</stkconfig>\n";
configfile.close();
}
catch (std::runtime_error& e)
{
std::cerr << "[UserConfig::saveConfig] ERROR: Failed to write config to " << filename.c_str()
<< "; cause : " << e.what() << "\n";
}
} // saveConfig
LoadBalancing::LoadBalancing() {
fdr_=0;
lastM=0;
is_lpmodel_created_=false;
quantiles_available_=false;
lp_D=NULL;
lp_G=NULL;
lp_E=NULL;
//Default configuration:
reconstruction_method_=RECONSTRUCTION_METHOD_DEFAULT;
bdr_update_coef_=BDR_UPDATE_COEF_DEFAULT;
fdr_update_coef_=FDR_UPDATE_COEF_DEFAULT;
scaling_coef_=SCALING_COEF_DEFAULT;
num_quantiles_=NUM_QUANTILES_DEFAULT;
solver_timeout_=SOLVER_TIMEOUT_DEFAULT;
multicast_enabled_=MULTICAST_DEFAULT;
use_fixed_uniform_cuts_=USE_FIXED_UNIFORM_CUTS_DEFAULT;
//Try to read config file in "loadbalancing_config.txt":
std::ifstream configfile(LB_CONFIG_FILE);
if(configfile){
std::cout << "LoadBalancing: Reading config from " << LB_CONFIG_FILE << std::endl;
LoadBalancingConfig lbconfig;
lbconfig.ParseConfigFile(LB_CONFIG_FILE);
LoadNewConfig(lbconfig);
}
}
//! Die Initialisierung des Servers mit Daten aus einer Datei
bool Init(const std::string &initfile) {
// first we try to open the file
std::ifstream configfile(initfile.c_str());
// can't read config file
if (!configfile.good()) {
return false;
}
std::string temp;
char buf[255];
// read first token of a line while there are any tokens left...
while (configfile >> temp && ! configfile.eof()) {
if (temp[0] == '#') {
// we found a comment... skip line
configfile.ignore(255,'\n'); // ignore up to 255 chars until \n is found
continue;
}
// store config options in map
configfile.ignore(1); // ignore the blank char following the token
configfile.getline(buf, 255, '\n');
configOptions[temp] = buf;
if (!configfile.good()) {
return false;
}
}
return true;
}
/** Write settings to config file. */
void UserConfig::saveConfig()
{
const std::string filename = file_manager->getUserConfigFile(m_filename);
std::stringstream ss;
ss << "<?xml version=\"1.0\"?>\n";
ss << "<stkconfig version=\"" << m_current_config_version
<< "\" >\n\n";
for (unsigned i = 0; i < all_params.size(); i++)
{
all_params[i]->write(ss);
}
ss << "</stkconfig>\n";
try
{
std::string s = ss.str();
std::ofstream configfile(filename.c_str(), std::ofstream::out);
configfile << ss.rdbuf();
configfile.close();
}
catch (std::runtime_error& e)
{
Log::error("UserConfig::saveConfig", "Failed to write config to %s, "
"because %s", filename.c_str(), e.what());
}
} // saveConfig
int main(int argc, char **argv)
{
// Convert first argument of argv[0] (full pathspec to this executable) to path where executable is found
char *dir = dirname(argv[0]);
chdir(dir);
// Read the ini file
std::string iniFileName("lib/Rel.ini");
std::ifstream configfile(iniFileName);
std::string cmd((std::istreambuf_iterator<char>(configfile)), std::istreambuf_iterator<char>());
// Empty or no ini file?
if (cmd.length() == 0) {
std::cerr << (std::string("Missing or Damaged .ini File: Unable to find ") + iniFileName).c_str() << std::endl;
return 10;
}
// Include command-line args.
std::string args("");
for (int i = 1; i < argc; i++)
args += std::string(" \"") + std::string(argv[i]) + std::string("\"");
// Uncomment the following line to use GTK2
// setenv("SWT_GTK3", "0", 1);
return system((cmd + args).c_str());
}
/** Write settings to config file. */
void UserConfig::saveConfig()
{
const std::string filename = file_manager->getUserConfigFile(m_filename);
try
{
std::ofstream configfile (filename.c_str(), std::ofstream::out);
configfile << "<?xml version=\"1.0\"?>\n";
configfile << "<stkconfig version=\"" << m_current_config_version
<< "\" >\n\n";
const int paramAmount = all_params.size();
for(int i=0; i<paramAmount; i++)
{
//Log::info("UserConfig", "Saving parameter %d to file", i);
all_params[i].write(configfile);
}
configfile << "</stkconfig>\n";
configfile.close();
}
catch (std::runtime_error& e)
{
Log::error("UserConfig::saveConfig", "Failed to write config to %s, because %s",
filename.c_str(), e.what());
}
} // saveConfig
TEST_F(SimplePipelineTest, test_simple_gaussiansinc_exact)
{
// Config file
std::string configfile(config_path + "fastimg_exact_gaussiansinc_config.json");
load_configdata(configfile);
// Execute pipeline based on the loaded configurations
stp::SourceFindImage sfimage = execute_pipeline();
int total_islands = sfimage.islands.size();
ASSERT_EQ(total_islands, 1);
int label_idx = sfimage.islands[0].label_idx;
int sign = sfimage.islands[0].sign;
double extremum_val = sfimage.islands[0].extremum_val;
int extremum_x_idx = sfimage.islands[0].extremum_x_idx;
int extremum_y_idx = sfimage.islands[0].extremum_y_idx;
double xbar = sfimage.islands[0].moments_fit.x_centre;
double ybar = sfimage.islands[0].moments_fit.y_centre;
EXPECT_EQ(label_idx, 1);
EXPECT_EQ(sign, 1);
EXPECT_NEAR(extremum_val, 0.11045229607808271, pipeline_tolerance);
EXPECT_EQ(extremum_x_idx, 824);
EXPECT_EQ(extremum_y_idx, 872);
EXPECT_NEAR(xbar, 823.435310857686, pipeline_tolerance);
EXPECT_NEAR(ybar, 871.615973834618, pipeline_tolerance);
}
int main(int argc, const char* argv[])
{
std::string text;
std::string filename;
std::string configuration;
auto homepath = std::getenv("HOME");
if(!homepath){
std::cout << "HOME env var not found!";
return 1;
}
configuration = std::getenv("HOME") ;
configuration += "/.config/demo.cfg";
po::options_description options("Options:");
options.add_options()
("help,h", "print help message")
("output", po::value<std::string>(), "file to print to");
std::ifstream configfile(configuration);
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, options), vm);
po::store(po::parse_environment(options, "DEMO_"), vm);
po::store(po::parse_config_file(configfile, options), vm);
po::notify(vm);
configfile.close();
if (vm.count("help") != 0)
{
std::cout << options << std::endl;
return 1;
}
std::string tmp;
while(std::cin >> tmp)
{
text += tmp;
if(!std::cin.eof())
{
text += " ";
}
}
if(vm.count("output") != 0)
{
std::ofstream out(vm["output"].as<std::string>());
std::cout<<text<<std::endl;
out.close();
} else {
std::ofstream out("default.log");
std::cout<<text<<std::endl;
out.close();
}
return 0;
}
void CRBXInput::WriteTranslations()
{
CConfigFile configfile( '=' );
configfile.loadConfig( TRCONFIG );
std::list<_trpair>::iterator t;
for( t = translations.begin(); t != translations.end(); t++ )
{
configfile.setInt32( GetKeyName( t->key ), t->rc );
}
std::cout << "Save config file with translations!" << std::endl;
configfile.saveConfig( TRCONFIG );
}
// ----------------------------------------------------------------------------
void writeServerConfigToDisk()
{
const std::string& config_xml = getServerConfigXML();
try
{
std::ofstream configfile(g_server_config_path.c_str(),
std::ofstream::out);
configfile << config_xml;
configfile.close();
}
catch (std::runtime_error& e)
{
Log::error("ServerConfig", "Failed to write server config to %s, "
"because %s", g_server_config_path.c_str(), e.what());
}
} // writeServerConfigToDisk
void QConfigMenu::on_showConfigBtn()
{
QFile configfile("config.txt");
if(!configfile.open(QIODevice::ReadOnly | QIODevice::Text))
{
QMessageBox::critical(this, tr("打开提示"), tr("配置文件不存在,请先生成配置文件！"), tr("确定"));
return;
}
QTextStream in(&configfile);
QString configOutput = in.readAll();
m_runConfigEdit->setText(configOutput);
m_runConfigEdit->setWindowModality(Qt::ApplicationModal);
m_runConfigEdit->show();
configfile.close();
}
bool LtcParams::Load(void) {
m_tLtcParams.nSetList = 0;
ReadConfigFile configfile(LtcParams::staticCallbackFunction, this);
if (configfile.Read(LtcParamsConst::FILE_NAME)) {
// There is a configuration file
if (m_pLTcParamsStore != 0) {
m_pLTcParamsStore->Update(&m_tLtcParams);
}
} else if (m_pLTcParamsStore != 0) {
m_pLTcParamsStore->Copy(&m_tLtcParams);
} else {
return false;
}
return true;
}
InputCatcher::InputCatcher(ALLEGRO_DISPLAY *display)
{
// Create an event queue, and error if it fails
event_queue = al_create_event_queue();
if (!event_queue)
{
fprintf(stderr, "Fatal Error: Could not create event queue!");
throw -1;
}
// Connect the window, keyboard and mouse events to this event queue
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
// al_register_event_source(event_queue, al_get_mouse_event_source(display));
std::ifstream configfile("config.json");
config << configfile;
configfile.close();
}
/*!
* \fn bool Write()
* \return true if everything is allright, false else.
*
* This function write configuration file, using a combinaison values already
* available and default values.
*/
bool ConfigManager::Write()
{
std::cout << "(function) ConfigManager::Write" << std::endl; // debug
// Write config file
std::ofstream configfile(path, std::ios::out);
if (!configfile)
{
return false;
}
else
{
//
std::string fullscreen_temp;
if (conf_rFullscreen == true)
fullscreen_temp= "on";
else
fullscreen_temp= "off";
// Edit
configfile
<< "<?xml version=\"1.0\" encoding=\"ASCII\"?>"
<< "\n<!-- MapMe : configuration -->"
<< "\n"
<< "\n<configuration>"
<< "\n <game version=\"" << conf_rameVersion << "\" />"
<< "\n <resolution resx=\"" << conf_rResx << "\" resy=\"" << conf_rResy << "\" fullscreen=\"" << fullscreen_temp << "\" />"
<< "\n <language lng=\"" << conf_lLng << "\" />"
<< "\n <volumes master=\"" << conf_vMaster << "\" music=\"" << conf_vMusic << "\" />"
<< "\n <network name=\"" << conf_nUser << "\" port=\"" << conf_nPort << "\" />"
<< "\n</configuration>"
<< std::endl;
// Close file
configfile.close();
// Update statut
return true;
}
}
//************************************************************************************************
// cMenu::SettingsMenu
//************************************************************************************************
void cMenu::SettingsMenu(int rc_fd)
{
CConfigFile configfile('\t');
configfile.loadConfig(VDRVIEWER_SETTINGS_FILE);
std::string serverip = configfile.getString("server", "10.10.10.10");
int osdport = configfile.getInt32("osdport", 20001);
int streamingport = configfile.getInt32("streamingport", 20002);
cMenu Menu("VDR-Viewer Einstellungen");
//Menu.Add(new cMenuStringItem("Server-Adresse", serverip));
Menu.Add(new cMenuIntItem("OSD-Port", &osdport, 100, 99999));
Menu.Add(new cMenuIntItem("Streaming-Port", &streamingport, 100, 99999));
Menu.Add(new cMenuSeparatorItem());
EMenuValue RetVal = Menu.Show(rc_fd);
configfile.getString("server", serverip);
configfile.setInt32("osdport", osdport);
configfile.setInt32("streamingport", streamingport);
configfile.saveConfig(VDRVIEWER_SETTINGS_FILE);
}
//Native RC
void CRBXInput::LoadNativeTranslations()
{
unsigned int i;
CConfigFile configfile( '=' );
configfile.loadConfig( TRCONFIG );
//i loop over all defined keys and check wheither there is a defined key value
for( i = UNKNOWN + 1; i < NOKEY; i++ )
{
_trpair tr;
tr.key = (KEYS)i;
tr.rc = configfile.getInt32( GetKeyName( (KEYS)i ) );
if( strcmp( "unknown", CRCInput::getSpecialKeyName( tr.rc ) ) )
{
bool flag = true;
std::list<_trpair>::iterator t;
for( t = translations.begin(); t != translations.end(); t++ )
{
if( t->key == (KEYS)i )
{
flag = false;
t->rc = tr.rc;
break;
}
}
if( flag )
{
translations.push_back( tr );
}
}
}
}
bool ArtNet4Params::Load(void) {
DEBUG_ENTRY
ArtNetParams::Load();
m_tArtNet4Params.nSetList = 0;
ReadConfigFile configfile(ArtNet4Params::staticCallbackFunction, this);
if (configfile.Read(ArtNetParamsConst::FILE_NAME)) {
// There is a configuration file
if (m_pArtNet4ParamsStore != 0) {
m_pArtNet4ParamsStore->Update(&m_tArtNet4Params);
}
} else if (m_pArtNet4ParamsStore != 0) {
m_pArtNet4ParamsStore->Copy(&m_tArtNet4Params);
} else {
DEBUG_EXIT
return false;
}
DEBUG_EXIT
return true;
}
int main(int argc, char*argv[]) {
// ████████ INITS 1 ████████
#ifndef COMMON_INITS1
cfg.init("bedlab.cfg");
ui2::init_ui();
Vec2i windowsize;
Vec2i screen_resolution = { int(VideoMode::getDesktopMode().width), int(VideoMode::getDesktopMode().height) };
if (cfg.getvar<int>("auto_winsize")) {
auto window_scale = cfg.getvar<Vec2>("window_scale");
windowsize = Vec2i(scal(Vec2(screen_resolution), window_scale));
}
else {
windowsize = cfg.getvar<Vec2i>("windowsize");
}
winsize = Vec2(windowsize);
//UI.init_console(); // ALWAYS AFTER SO IT CAN GET WINDOW SIZE
ui2::init_console(); // ALWAYS AFTER SO IT CAN GET WINDOW SIZE
wincenter = 0.5f*Vec2(windowsize);
Vec2i windowpos;
VideoMode::getDesktopMode().height;
if (cfg.getvar<int>("stick_left")) {
windowpos = Vec2i(
screen_resolution.x - windowsize.x - 10,
screen_resolution.y - windowsize.y - 40
);
}
else
windowpos = (Vec2i(5, 25));
sf::RenderWindow window(sf::VideoMode(windowsize.x, windowsize.y),
"bedlab!", 7
//,sf::ContextSettings(0, 0, 1)
);
window.setFramerateLimit(cfg.getvar<int>("fps_max"));
frame_duration = 1.0f / cfg.getvar<int>("fps_max");
window.setPosition(windowpos);
vector<string> keys;
auto choice = cfg.getstr("app");
// show_keys(cfg.getstr("app"), keys);
#endif
// ████████ INITS2 ████████
#ifndef COMMON_INITS2
// we don't have a class/interface/struct with data, everything is local to this function, like a classic stack that all programs are anyway.
// Texture cursor_tx;
// if (!cursor_tx.loadFromFile(cfg.getstr("cursor")))
// cout << "did not load cursor" << endl;
// Sprite cursor;
// cursor.setTexture(cursor_tx);
// cursor.setOrigin(3, 3);
CircleShape cursor = mkcircle({ 0,0 }, Color::Transparent, 3, 1);
Color background = cfg.getvar<Color>("background");
window.setMouseCursorVisible(false);
Vec2 mpos;
bool leftclicked = false, rightclicked = false;
// view and zoom
View view, ui_view;
ui_view = view = window.getDefaultView();
float zoomlevel = 1;
Vec2 mpos_abs;
float frame_duration = 1.0f / cfg.getvar<int>("fps_max");
#endif // COMMON_INITS2
// ████████ APP ACTUAL ████████
float smaller_size = min(windowsize.y, windowsize.x);
string descriptor;
Transform transf;
transf.translate(10, 10);
transf.scale(Vec2(smaller_size, smaller_size));
transf_glob = transf;
auto addvt_col = [&](Vec2 v, Color col) {
glob_vert_single.append(Vertex(transf.transformPoint(v), col));
};
auto va_to_va_col = [&](mesh2d&idxd_v, Color col) {
for (unsigned int i = 0; i < idxd_v.size(); ++i)
{
// if (i<)
addvt_col(idxd_v[i].first, col);
addvt_col(idxd_v[i].second, col);
//addpt(idxd_v[i].first, Orange, 5);
//addpt(idxd_v[i].second, Cyan, 5);
}
for (auto&a : idxd_v.verts) {
addpt_col(a, col, 2);
}
};
auto stripify = [&](vector<Vec2> strip, Color col) {
glob_vert_single = VertexArray(LineStrip);
for (auto&a : strip) {
glob_vert_single.append(Vertex(transf.transformPoint(a), col));
addpt_col(a, col, 2);
}
};
size_t edit_mode = 1;
// ████████████████████████████████████████
sf::Sound sound;
auto make_segment = [](int size, int amplitude) {
vector<Int16> sample;
for (int i = 0; i < size; ++i)
{
sample.push_back(amplitude*sin(float(i)*PI*2.0f));
}
return sample;
};
/*
<Jonny> duration will be sample count * sample rate
<Jonny> so at 44khz you'll have 44k samples per second
<Jonny> if you have 88k samples that will last 2 second
*/
plot_bare pl;
float sample_rate = 22050;
auto make_tone = [&](float duration, float frequency, int amplitude_exp) {
float sample_quantity = sample_rate * duration;
vector<Int16> sample;
int amplitude = 1 << amplitude_exp;
float increment = frequency / sample_rate;
float x = 0;
for (int i = 0; i < sample_quantity; ++i){
sample.push_back(amplitude*sin(float(x)*PI*2.0f));
x += increment;
}
return sample;
};
// http://sol.gfxile.net/interpolation/
auto make_tone_progressive_2 = [&](float duration, float frequency, int amplitude_exp) {
float sample_quantity = sample_rate * duration;
vector<Int16> sample;
int amplitude = 1 << amplitude_exp;
float increment = frequency / sample_rate;
float x = 0;
for (int i = 0; i < sample_quantity; ++i) {
float soft = float(i) / sample_quantity;
//soft = 1 - (1 - 2 * soft)*(1 - 2 * soft)*(1 - 2 * soft)*(1 - 2 * soft);
soft = 1 - (1 - 2 * soft)*(1 - 2 * soft);
soft *= amplitude;
sample.push_back(soft*sin(float(x)*PI*2.0f));
x += increment;
}
return sample;
};
auto make_tone_progressive_4 = [&](float duration, float frequency, int amplitude_exp) {
float sample_quantity = sample_rate * duration;
vector<Int16> sample;
int amplitude = 1 << amplitude_exp;
float increment = frequency / sample_rate;
float x = 0;
for (int i = 0; i < sample_quantity; ++i) {
float soft = float(i) / sample_quantity;
soft = 1 - (1 - 2 * soft)*(1 - 2 * soft)*(1 - 2 * soft)*(1 - 2 * soft);
soft *= amplitude;
sample.push_back(soft*sin(float(x)*PI*2.0f));
x += increment;
}
return sample;
};
auto make_tone_progressive_6 = [&](float duration, float frequency, int amplitude_exp) {
float sample_quantity = sample_rate * duration;
vector<Int16> sample;
int amplitude = 1 << amplitude_exp;
float increment = frequency / sample_rate;
float x = 0;
for (int i = 0; i < sample_quantity; ++i) {
float soft = float(i) / sample_quantity;
soft = 1 - (1 - 2 * soft)*(1 - 2 * soft)*(1 - 2 * soft)*(1 - 2 * soft)*(1 - 2 * soft)*(1 - 2 * soft);
soft *= amplitude;
sample.push_back(soft*sin(float(x)*PI*2.0f));
x += increment;
}
return sample;
};
auto sample_string2 = cfg.getstr("sound1");
auto spl1 = splitdelim(sample_string2, ',');
auto params2 = splitdelim(spl1[0]);
//float freq = parse<float>(params[1]);
//float duration = parse<float>(params[2]);
//float amplitude_exp = parse<float>(params[3]);
float freq, duration, amplitude_exp, pause;
int times, smoothstep_exp;
dip_bars dbars(FONT, FONTSIZE, {400,20});
//dbars.add("sampling", &sampling,5, 10000);
dbars.add("sample_rate", &sample_rate, 1000, 45000);
dbars.add("freq", &freq,50,5000);
dbars.add("duration", &duration, 0.5, 5);
dbars.add("amplitude_exp", &litude_exp, 1, 14);
SoundBuffer buffer; // always lived!
auto load_sample2 = [&](){
auto delaystr = splitdelim(spl1[1]);
vector<float> segment_sizes;
float total = 0;
for (auto&a : delaystr) {
total += parse<float>(a);
segment_sizes.push_back(parse<float>(a));
}
int i = 0;
vector<Int16> sample;
vector<vector<Int16>> samples;
for (auto&a : segment_sizes) a /= total;
//for (auto&a : segment_sizes) msg(a*total);
for (auto&a : segment_sizes){
auto scaled_back = duration * freq * a;
int amplitude = i % 2 ? 0 : 1 << int(amplitude_exp);
msg(scaled_back);
samples.push_back(make_segment(scaled_back, amplitude));
++i;
}
for (auto&a : samples){
concatenate(sample, a);
}
SoundBuffer buffer;
// \param sampleRate Sample rate (number of samples to play per second)
buffer.loadFromSamples(&sample[0], sample.size(), 1, sample.size()/duration);
{
// plut josting just plotting
vector<Vec2> plot_this;
int i = 0;
for (auto&a : sample) {
//plot_this.push_back({ float(i), 200 * float(a) / (1 << 12) });
plot_this.push_back({ float(i), float(a) });
i++;
}
pl.clear();
pl.from_data_normalized(plot_this);
}
return buffer;
};
auto load_sample = [&]() {
auto delaystr = splitdelim(spl1[1]);
vector<float> segment_sizes;
float total = 0;
for (auto&a : delaystr) {
total += parse<float>(a);
segment_sizes.push_back(parse<float>(a));
}
int i = 0;
vector<Int16> sample;
vector<vector<Int16>> samples;
for (auto&a : segment_sizes) a /= total;
//for (auto&a : segment_sizes) msg(a*total);
if (smoothstep_exp == 2) {
for (auto&a : segment_sizes) {
samples.push_back(make_tone_progressive_2(duration*a, freq, i % 2 ? 0 : int(amplitude_exp)));
++i;
}
}
else if (smoothstep_exp == 4){
for (auto&a : segment_sizes) {
samples.push_back(make_tone_progressive_4(duration*a, freq, i % 2 ? 0 : int(amplitude_exp)));
++i;
}
}
for (auto&a : samples) {
concatenate(sample, a);
}
SoundBuffer buffer;
// \param sampleRate Sample rate (number of samples to play per second)
//sample = make_tone(2, 400, 8);
//buffer.loadFromSamples(&sample[0], sample.size(), 1, sample.size() / duration);
buffer.loadFromSamples(&sample[0], sample.size(), 1, sample.size() / duration);
if (true) {
// plut josting just plotting
vector<Vec2> plot_this;
int i = 0;
for (auto&a : sample) {
//plot_this.push_back({ float(i), 200 * float(a) / (1 << 12) });
plot_this.push_back({ float(i), float(a) });
i++;
}
pl.clear();
pl.from_data_normalized(plot_this);
}
return buffer;
};
auto load_from_cfg = [
&freq,
&duration,
&litude_exp,
&pause,
×,
&descriptor,
&smoothstep_exp]() {
auto temp_cfg = configfile();
temp_cfg.init("bedlab.cfg");
auto sample_string = temp_cfg.getstr("sound2");
auto things = split2(sample_string, ",");
auto params = split2(things[0], " ");
auto segments = split2(things[1], " ");
string segments_dashed = things[1];
if (segments_dashed[0] == ' ') segments_dashed = segments_dashed.substr(1);
if (things[1][0] == ' ') things[1] = things[1].substr(1);
if (things[2][0] == ' ') things[2] = things[2].substr(1);
if (things[3][0] == ' ') things[3] = things[3].substr(1);
if (things[4][0] == ' ') things[4] = things[4].substr(1);
for (auto&c : segments_dashed) {
if (c == ' ') c = '-';
}
freq = parse<float>(params[0]);
duration = parse<float>(params[1]);
amplitude_exp = parse<float>(params[2]);
pause = parse<float>(things[2]);
times = parse<int>(things[3]);
smoothstep_exp = parse<int>(things[4]);
msgs(smoothstep_exp);
descriptor =
params[0] // freq
+ "_" + params[1] // duration
+ "_" + params[2] // amplitude_exp
+ "_" + segments_dashed
+ "_" + things[2] // pause
+ "_" + things[3] // times
+ "_" + things[4] // smoothstep_exp
;
msgs(descriptor);
return segments;
};
auto segments = load_from_cfg();
auto flexible_expanse = [&]() {
vector<float> segment_sizes, segment_concat;
for (auto&a : segments) {
segment_sizes.push_back(parse<float>(a));
}
segment_sizes.push_back(pause);
for (int i = 0; i < times; ++i) {
concatenate(segment_concat, segment_sizes);
}
float total = 0;
for (auto&a : segment_concat) total+=a;
for (auto&a : segment_concat) a /= total;
vector<vector<Int16>> samples;
int i = 0;
if (smoothstep_exp == 2) {
for (auto&a : segment_concat) {
samples.push_back(make_tone_progressive_2(duration*a, freq, i % 2 ? 0 : int(amplitude_exp)));
++i;
}
}
else if (smoothstep_exp == 4) {
for (auto&a : segment_concat) {
samples.push_back(make_tone_progressive_4(duration*a, freq, i % 2 ? 0 : int(amplitude_exp)));
++i;
}
}
else if (smoothstep_exp == 6) {
for (auto&a : segment_concat) {
samples.push_back(make_tone_progressive_6(duration*a, freq, i % 2 ? 0 : int(amplitude_exp)));
++i;
}
}
vector<Int16> sample;
for (auto&a : samples) { concatenate(sample, a); }
SoundBuffer buffer;
//buffer.loadFromSamples(&sample[0], sample.size(), 1, sample.size() / duration);
buffer.loadFromSamples(&sample[0], sample.size(), 1, sample_rate);
if (true) {
// plut josting just plotting
vector<Vec2> plot_this;
int i = 0;
for (auto&a : sample) {
//plot_this.push_back({ float(i), 200 * float(a) / (1 << 12) });
plot_this.push_back({ float(i), float(a) });
i++;
}
pl.clear();
pl.from_data_normalized(plot_this);
}
return buffer;
};
//buffer = load_sample(sample_string);
auto make_sound = [&]() {
//buffer = load_sample();
segments = load_from_cfg();
buffer = flexible_expanse();
sound.setBuffer(buffer);
string filename = "rngtn_" + descriptor+".wav";
//buffer.saveToFile("file.wav");
buffer.saveToFile(filename);
sound.play();
};
make_sound();
dbars.read_from_pointers();
// ████████ callbacks ████████
#ifndef LOOP_LAMBDAS
draw = [&]() {
window.setView(view);
//////////////// OBJECTS THAT CAN ZOOMED ////////////////
window.draw(glob_vert_single);
for (auto&a : glob_pts)window.draw(a);
for (auto&a : glob_rects)window.draw(a);
for (auto&a : glob_vert)window.draw(a);
for (auto&a : glob_texts)window.draw(a);
// UI draw, AFTER ui view and BEFORE other draw
window.setView(ui_view);
//////////////// OBJECTS THAT CANNOT ZOOMED, MEANING UI ////////////////
pl.draw(window);
dbars.draw(window);
//br.drawwithtext(window);
UI.draw(window);
window.draw(cursor);
};
update = [&]() {
};
treatkeyevent = [&](Keyboard::Key k) {
switch (k)
{
case Keyboard::E:
break;
case Keyboard::I:
break;
case Keyboard::Q:
break;
case Keyboard::BackSpace:
glob_pts.clear();
glob_texts.clear();
glob_rects.clear();
glob_vert.clear();
break;
case Keyboard::Space:
make_sound();
sound.play();
sound.setLoop(false);
break;
case Keyboard::S:
screenshot(window);
break;
case Keyboard::Num1:
case Keyboard::Num2:
case Keyboard::Num3:
case Keyboard::Num4:
case Keyboard::Num5:
break;
}
};
mousemoved = [&](Vec2 pos) {
cursor.setPosition(pos);
if (leftclicked);
dbars.mouse_moved(pos);
};
mouseclick = [&](sf::Mouse::Button button) {
if (button == Mouse::Button::Left) leftclicked = true;
if (button == Mouse::Button::Right) rightclicked = true;
if (button == Mouse::Button::Left) dbars.mouse_click(mpos);
};
mouserelease = [&](sf::Mouse::Button button) {
if (button == Mouse::Button::Left) leftclicked = false;
if (button == Mouse::Button::Right) rightclicked = false;
if (button == Mouse::Button::Left) {
dbars.mouse_release();
make_sound();
}
};
loop = [&]() {
while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
switch (event.type)
{
case sf::Event::KeyPressed:
if (event.key.code == sf::Keyboard::Escape)
window.close();
treatkeyevent(event.key.code);
break;
case sf::Event::Closed:
window.close();
break;
case sf::Event::MouseButtonPressed:
mouseclick(event.mouseButton.button);
break;
case sf::Event::MouseButtonReleased:
mouserelease(event.mouseButton.button);
break;
case sf::Event::MouseMoved:
mpos = Vec2(event.mouseMove.x, event.mouseMove.y);
mpos_abs = window.mapPixelToCoords(Vec2i(mpos), view);
mousemoved(mpos);
break;
default:
treatotherevent(event);
break;
}
}
window.clear(background);
update();
draw();
window.display();
}
};
treatotherevent = [&](Event&e) {
if (e.type == Event::MouseWheelMoved && e.mouseWheel.delta)
{
mpos_abs = window.mapPixelToCoords(Vec2i(mpos), view);
//view = window.getView();
if (e.mouseWheel.delta < 0)
{
zoomlevel *= 2.f;
view.setSize(view.getSize()*2.f);
view.setCenter(interp(mpos_abs, view.getCenter(), 2.f));
//view.setCenter(interp(mpos_abs, view.getCenter(), 2.f));
}
if (e.mouseWheel.delta > 0)
{
zoomlevel *= 0.5;
view.setSize(view.getSize()*.5f);
view.setCenter(.5f*(view.getCenter() + mpos_abs));
//view.setCenter(.5f*(view.getCenter() + mpos_abs));
}
window.setView(view);
}
};
#endif // LOOP_LAMBDAS
loop();
}
void SparkFunDmx::ReadConfigFiles(void) {
DEBUG_ENTRY;
m_bIsSpiCsSet = false;
m_bIsResetSet = false;
m_bIsBusyPinSet = false;
ReadConfigFile configfile(SparkFunDmx::staticCallbackFunction, this);
if (configfile.Read("sparkfun.txt")) {
#ifndef NDEBUG
printf("\'sparkfun.txt\' (global settings):\n");
if (m_bIsSpiCsSet) {
printf("\tSPI CS : %d\n", m_nSpiCs);
}
if (m_bIsResetSet) {
printf("\tReset pin: %d\n", m_nResetPin);
}
if (m_bIsBusyPinSet) {
printf("\tBusy pin: %d\n", m_nBusyPin);
}
#endif
}
if (!m_bIsResetSet) {
m_nResetPin = GPIO_RESET_OUT;
m_bIsResetSet = true;
#ifndef NDEBUG
printf("\tReset pin: %d\n", m_nResetPin);
#endif
}
if (m_bIsBusyPinSet) {
bcm2835_gpio_fsel(m_nBusyPin, BCM2835_GPIO_FSEL_INPT);
}
bcm2835_gpio_fsel(m_nResetPin, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_set(m_nResetPin);
bcm2835_gpio_clr(m_nResetPin);
udelay(10000);
bcm2835_gpio_set(m_nResetPin);
udelay(10000);
bcm2835_spi_begin();
char fileName[] = "motor%.txt";
for (int i = 0; i < SPARKFUN_DMX_MAX_MOTORS; i++) {
fileName[5] = (char) i + '0';
m_bIsPositionSet = false;
if (configfile.Read(fileName)) {
#ifndef NDEBUG
printf("Motor %d:\n", i);
#endif
if (m_bIsPositionSet && m_bIsSpiCsSet) {
#ifndef NDEBUG
printf("\t%s=%d\n", SPARKFUN_PARAMS_POSITION, m_nPosition);
printf("\t%s=%d\n", SPARKFUN_PARAMS_SPI_CS, m_nSpiCs);
printf("\t%s=%d\n", SPARKFUN_PARAMS_RESET_PIN, m_nResetPin);
if(m_bIsBusyPinSet) {
printf("\t%s=%d\n", SPARKFUN_PARAMS_BUSY_PIN, m_nBusyPin);
}
printf("\t-----------------------------\n");
printf("\t%s=%d (DMX footprint=%d)\n", PARAMS_DMX_MODE, m_nDmxMode, L6470DmxModes::GetDmxFootPrintMode(m_nDmxMode));
printf("\t%s=%d\n", PARAMS_DMX_START_ADDRESS, m_nDmxStartAddressMode);
printf("\t=============================\n");
#endif
if ((m_nDmxStartAddressMode <= DMX_MAX_CHANNELS) && (L6470DmxModes::GetDmxFootPrintMode(m_nDmxMode) != 0)) {
if (m_bIsBusyPinSet) {
m_pAutoDriver[i] = new AutoDriver(m_nPosition, m_nSpiCs, m_nResetPin, m_nBusyPin);
} else {
m_pAutoDriver[i] = new AutoDriver(m_nPosition, m_nSpiCs, m_nResetPin);
}
assert(m_pAutoDriver[i] != 0);
if (m_pAutoDriver[i] != 0) {
if (m_pAutoDriver[i]->IsConnected()) {
m_pAutoDriver[i]->setMotorNumber(i);
m_pAutoDriver[i]->Dump();
m_pMotorParams[i] = new MotorParams(fileName);
assert(m_pMotorParams[i] != 0);
m_pMotorParams[i]->Dump();
m_pMotorParams[i]->Set(m_pAutoDriver[i]);
L6470Params l6470Params(fileName);
l6470Params.Dump();
l6470Params.Set(m_pAutoDriver[i]);
m_pAutoDriver[i]->Dump();
m_pModeParams[i] = new ModeParams(fileName);
assert(m_pModeParams[i] != 0);
m_pModeParams[i]->Dump();
m_pL6470DmxModes[i] = new L6470DmxModes((TL6470DmxModes) m_nDmxMode, m_nDmxStartAddressMode, m_pAutoDriver[i], m_pMotorParams[i], m_pModeParams[i]);
assert(m_pL6470DmxModes[i] != 0);
if (m_pL6470DmxModes[i] != 0) {
if (m_nDmxStartAddress == DMX_ADDRESS_INVALID) {
m_nDmxStartAddress = m_pL6470DmxModes[i]->GetDmxStartAddress();
m_nDmxFootprint = m_pL6470DmxModes[i]->GetDmxFootPrint();
} else {
const uint16_t nDmxChannelLastCurrent = m_nDmxStartAddress + m_nDmxFootprint;
m_nDmxStartAddress = MIN(m_nDmxStartAddress, m_pL6470DmxModes[i]->GetDmxStartAddress());
const uint16_t nDmxChannelLastNew = m_nDmxStartAddressMode + m_pL6470DmxModes[i]->GetDmxFootPrint();
m_nDmxFootprint = MAX(nDmxChannelLastCurrent, nDmxChannelLastNew) - m_nDmxStartAddress;
}
#ifndef NDEBUG
printf("DMX Mode: %d, DMX Start Address: %d\n", m_pL6470DmxModes[i]->GetMode(), m_pL6470DmxModes[i]->GetDmxStartAddress());
printf("DMX Start Address:%d, DMX Footprint:%d\n", (int) m_nDmxStartAddress, (int) m_nDmxFootprint);
#endif
}
} else {
delete m_pAutoDriver[i];
m_pAutoDriver[i] = 0;
printf("Communication issues; check SPI configuration and cables\n");
}
} else {
printf("Internal error!\n");
}
}
} else {
if(!m_bIsPositionSet) {
printf("Missing %s=\n", SPARKFUN_PARAMS_POSITION);
}
if(!m_bIsSpiCsSet) {
printf("Missing %s=\n", SPARKFUN_PARAMS_SPI_CS);
}
}
#ifndef NDEBUG
printf("Motor %d: --------- end ---------\n", i);
#endif
} else {
#ifndef NDEBUG
printf("Configuration file : %s not found\n", fileName);
#endif
}
}
for (int i = 0; i < SPARKFUN_DMX_MAX_MOTORS; i++) {
if (m_pL6470DmxModes[i] != 0) {
m_pL6470DmxModes[i]->InitSwitch();
}
}
for (int i = 0; i < SPARKFUN_DMX_MAX_MOTORS; i++) {
if (m_pAutoDriver[i] != 0) {
while (m_pAutoDriver[i]->busyCheck())
;
}
}
for (int i = 0; i < SPARKFUN_DMX_MAX_MOTORS; i++) {
if (m_pL6470DmxModes[i] != 0) {
m_pL6470DmxModes[i]->InitPos();
}
}
#ifndef NDEBUG
printf("Motors connected : %d\n", (int) AutoDriver::getNumBoards());
#endif
DEBUG_EXIT;
}
void runGRJETSv11(TString mode = "lite", // local, lite, or cluster
TString identifier = "run1", // tag
TString dataset = "Wprime1200.GRJETSv11", // dataset name as in the fileList
TString username = "******", // username (e.g. swiatlow, fizisist)
bool mcweights = false, // use mc weights?
bool doHists = true, // do histograms or enable dataset mode
bool doSys = false, // do systematics
bool debug = false, // turn on debugging
int nWorkers = 4 //specify number of workers for proof(-1 for all available)
)
{
///----------------------------------------------------------------
/// Load libraries , set the config file, treenam, and cluster info
///----------------------------------------------------------------
TString gridusername = "******";
cout << "trying to load libraries" << endl;
loadLibraries();
cout << " Libraries loaded " << endl;
// SetConfig
TString configfile("../config/grjetsv11.config");
// Change if defaulting to wrong TTree, otherwise leave
TString treename("jets");
// Best to leave alone
TString pathLite("");
TString pathCluster("root://atlprf01.slac.stanford.edu:2094//atlas/output/");
pathCluster.Append(username);
pathCluster.Append("/");
// Determine eventbuilder from dataset name
TString eventbuilder(dataset);
eventbuilder.Remove(0,eventbuilder.Last('.')+1);
///----------------------------------------------------------------
/// Filename paths, URLs for PROOF running
///----------------------------------------------------------------
TString url(mode);
TString path("");
if (mode.CompareTo("lite")==0) {
url = "lite://";
path = pathLite;
}
else if(mode.CompareTo("cluster")==0) {
url = TString(username+"@atlprf01.slac.stanford.edu");
path = pathCluster;
}
// Make an options file, edit as needed
TFile* options = new TFile("options.root","RECREATE");
///----------------------------------------------------------------
/// Overall Configuration
///----------------------------------------------------------------
bool doPRW = false;
bool doBasic = true;
bool doTruthLinks = false;
bool doTrackJetLinks = true;
bool doTruthJetLinks = true;
bool doJetStructure = true;
bool doConstituents = true;
bool doTruthConstit = true;
bool doParentChild = true;
bool doTrack = true;
bool doLCCluster = true;
bool doEMCluster = false;
bool doTruth = true;
bool doVertex = true;
bool doPhotons = false;
/// JET TYPES
bool doSomeJetTypes = false;
bool doMinJetTypes = true;
/// SELECTIONS
float minJetPt = 20.000;
float maxJetEta = 3.199;
float minFatJetPt = 100.000;
float minJetJVF = 0.750;
float maxJetTrkDR = 0.300;
float maxJetTruthDR = 0.300;
TString badJetType = "AntiKt4LCTopoAOD";
TString badJetDef = "isBadLooseMinus";
/// Substructure
int nStdJetCut = 4;
float lowMassCRcut = 100.000;
float threeBodyCRcut = 0.700;
///----------------------------------------------------------------
/// Jet types
///----------------------------------------------------------------
TString aktCal = "AntiKt10LCTopo";
TString aktTrk = "AntiKt10TrackZ";
TString aktTru = "AntiKt10Truth";
TString caCal = "CamKt12LCTopo";
TString caTrk = "CamKt12TrackZ";
TString caTru = "CamKt12Truth";
TString aktCalTrim = "AntiKt10LCTopoTrimmedPtFrac1SmallR20,AntiKt10LCTopoTrimmedPtFrac3SmallR20,AntiKt10LCTopoTrimmedPtFrac5SmallR20,AntiKt10LCTopoTrimmedPtFrac1SmallR30,AntiKt10LCTopoTrimmedPtFrac3SmallR30,AntiKt10LCTopoTrimmedPtFrac5SmallR30";
TString aktCalPrun = "AntiKt10LCTopoPrunedKtRcutFactor10Zcut5,AntiKt10LCTopoPrunedKtRcutFactor20Zcut5,AntiKt10LCTopoPrunedKtRcutFactor30Zcut5,AntiKt10LCTopoPrunedKtRcutFactor10Zcut10,AntiKt10LCTopoPrunedKtRcutFactor20Zcut10,AntiKt10LCTopoPrunedKtRcutFactor30Zcut10";
TString aktTrkTrim = "AntiKt10TrackZTrimmedPtFrac1SmallR20,AntiKt10TrackZTrimmedPtFrac3SmallR20,AntiKt10TrackZTrimmedPtFrac5SmallR20,AntiKt10TrackZTrimmedPtFrac1SmallR30,AntiKt10TrackZTrimmedPtFrac3SmallR30,AntiKt10TrackZTrimmedPtFrac5SmallR30";
TString aktTrkPrun = "AntiKt10TrackZPrunedKtRcutFactor10Zcut5,AntiKt10TrackZPrunedKtRcutFactor20Zcut5,AntiKt10TrackZPrunedKtRcutFactor30Zcut5,AntiKt10TrackZPrunedKtRcutFactor10Zcut10,AntiKt10TrackZPrunedKtRcutFactor20Zcut10,AntiKt10TrackZPrunedKtRcutFactor30Zcut10";
TString aktTruTrim = "AntiKt10TruthTrimmedPtFrac1SmallR20,AntiKt10TruthTrimmedPtFrac3SmallR20,AntiKt10TruthTrimmedPtFrac5SmallR20,AntiKt10TruthTrimmedPtFrac1SmallR30,AntiKt10TruthTrimmedPtFrac3SmallR30,AntiKt10TruthTrimmedPtFrac5SmallR30";
TString aktTruPrun = "AntiKt10TruthPrunedKtRcutFactor10Zcut5,AntiKt10TruthPrunedKtRcutFactor20Zcut5,AntiKt10TruthPrunedKtRcutFactor30Zcut5,AntiKt10TruthPrunedKtRcutFactor10Zcut10,AntiKt10TruthPrunedKtRcutFactor20Zcut10,AntiKt10TruthPrunedKtRcutFactor30Zcut10";
TString caCalTrim = "CamKt12LCTopoTrimmedPtFrac1SmallR20,CamKt12LCTopoTrimmedPtFrac3SmallR20,CamKt12LCTopoTrimmedPtFrac5SmallR20,CamKt12LCTopoTrimmedPtFrac1SmallR30,CamKt12LCTopoTrimmedPtFrac3SmallR30,CamKt12LCTopoTrimmedPtFrac5SmallR30";
TString caCalPrun = "CamKt12LCTopoPrunedKtRcutFactor10Zcut5,CamKt12LCTopoPrunedKtRcutFactor20Zcut5,CamKt12LCTopoPrunedKtRcutFactor30Zcut5,CamKt12LCTopoPrunedKtRcutFactor10Zcut10,CamKt12LCTopoPrunedKtRcutFactor20Zcut10,CamKt12LCTopoPrunedKtRcutFactor30Zcut10";
TString caCalFilt = "CamKt12LCTopoSplitFilteredmassFraction20minSplitR0,CamKt12LCTopoSplitFilteredmassFraction33minSplitR0,CamKt12LCTopoSplitFilteredmassFraction67minSplitR0";
TString caTrkTrim = "CamKt12TrackZTrimmedPtFrac1SmallR20,CamKt12TrackZTrimmedPtFrac3SmallR20,CamKt12TrackZTrimmedPtFrac5SmallR20,CamKt12TrackZTrimmedPtFrac1SmallR30,CamKt12TrackZTrimmedPtFrac3SmallR30,CamKt12TrackZTrimmedPtFrac5SmallR30";
TString caTrkPrun = "CamKt12TrackZPrunedKtRcutFactor10Zcut5,CamKt12TrackZPrunedKtRcutFactor20Zcut5,CamKt12TrackZPrunedKtRcutFactor30Zcut5,CamKt12TrackZPrunedKtRcutFactor10Zcut10,CamKt12TrackZPrunedKtRcutFactor20Zcut10,CamKt12TrackZPrunedKtRcutFactor30Zcut10";
TString caTrkFilt = "CamKt12TrackZSplitFilteredmassFraction20minSplitR0,CamKt12TrackZSplitFilteredmassFraction33minSplitR0,CamKt12TrackZSplitFilteredmassFraction67minSplitR0";
TString caTruTrim = "CamKt12TruthTrimmedPtFrac1SmallR20,CamKt12TruthTrimmedPtFrac3SmallR20,CamKt12TruthTrimmedPtFrac5SmallR20,CamKt12TruthTrimmedPtFrac1SmallR30,CamKt12TruthTrimmedPtFrac3SmallR30,CamKt12TruthTrimmedPtFrac5SmallR30";
TString caTruPrun = "CamKt12TruthPrunedKtRcutFactor10Zcut5,CamKt12TruthPrunedKtRcutFactor20Zcut5,CamKt12TruthPrunedKtRcutFactor30Zcut5,CamKt12TruthPrunedKtRcutFactor10Zcut10,CamKt12TruthPrunedKtRcutFactor20Zcut10,CamKt12TruthPrunedKtRcutFactor30Zcut10";
TString caTruFilt = "CamKt12TruthSplitFilteredmassFraction20minSplitR0,CamKt12TruthSplitFilteredmassFraction33minSplitR0,CamKt12TruthSplitFilteredmassFraction67minSplitR0";
//// Make derived lists
TString aktData = aktCal + "," + aktTrk + "," + aktCalTrim + "," + aktCalPrun + "," + aktTrkTrim + "," + aktTrkPrun;
TString aktMC = aktTru + "," + aktTruTrim + "," + aktTruPrun;
TString caData = caCal + "," + caTrk + "," + caCalTrim + "," + caCalPrun + "," + caCalFilt + "," + caTrkTrim + "," + caTrkPrun + "," + caTrkFilt;
TString caMC = caTru + "," + caTruTrim + "," + caTruPrun + "," + caTruFilt;
//// DEFAULT FULL LIST
TString jetTypes = aktData + "," + caData;
if (!dataset.Contains("data")) jetTypes += "," + aktMC + "," + caMC;
//// REDUCED SET OF JETS
if (doSomeJetTypes) {
jetTypes = "AntiKt10LCTopo,CamKt12LCTopo,AntiKt10LCTopoTrimmedPtFrac3SmallR30,AntiKt10LCTopoTrimmedPtFrac5SmallR30,CamKt12LCTopoSplitFilteredmassFraction67minSplitR0,AntiKt10TrackZ,CamKt12TrackZ,AntiKt10TrackZTrimmedPtFrac3SmallR30,AntiKt10TrackZTrimmedPtFrac5SmallR30,CamKt12TrackZSplitFilteredmassFraction67minSplitR0";
if (!dataset.Contains("data")) jetTypes += ",AntiKt10Truth,CamKt12Truth,AntiKt10TruthTrimmedPtFrac3SmallR30,AntiKt10TruthTrimmedPtFrac5SmallR30,CamKt12TruthSplitFilteredmassFraction67minSplitR0";
}
else if (!doSomeJetTypes && doMinJetTypes) {
jetTypes = "AntiKt10LCTopo,CamKt12LCTopo,AntiKt10LCTopoTrimmedPtFrac5SmallR30,CamKt12LCTopoSplitFilteredmassFraction67minSplitR0,AntiKt10TrackZ,CamKt12TrackZ,AntiKt10TrackZTrimmedPtFrac5SmallR30,CamKt12TrackZSplitFilteredmassFraction67minSplitR0";
if (!dataset.Contains("data")) jetTypes += ",AntiKt10Truth,CamKt12Truth,AntiKt10TruthTrimmedPtFrac5SmallR30,CamKt12TruthSplitFilteredmassFraction67minSplitR0";
}
//jetTypes = aktCal + "," + aktTrk + "," + aktCalTrim + "," + aktTrkTrim;
//jetTypes = caCal + "," + caTrk + "," + caCalTrim + "," + caTrkTrim;
//jetTypes = aktCalPrun + "," + aktTrkPrun + "," + caCalPrun + "," + caTrkPrun;
//jetTypes = caCalFilt + "," + caTrkFilt;
// Be careful when loading up subjettypes and btagtypes: check that
// these exist in the D3PD before trying to register them!
TString subjetTypes = "AntiKt10LCTopoTrimmedSubjetsPtFrac3SmallR30,AntiKt10TrackZTrimmedSubjetsPtFrac3SmallR30,AntiKt10TruthTrimmedSubjetsPtFrac3SmallR30";
TString btagTypes = "AntiKt10LCTopoTrimmedSubjetsPtFrac3SmallR30";
///---------------------------------------------------------------
/// New jet types! These will be constructed on the fly
///---------------------------------------------------------------
TString baseCustomTrimming = "AntiKtLCTopo15";
TString ptFracCustomTrimming = "0.05";
TString smallRCustomTrimming = "0.3";
///----------------------------------------------------------------
/// Nominal Configuration
///----------------------------------------------------------------
Config* chain = new Config("chain",configfile);
chain->AddVec("ANALYSIS");
Config* setup = new Config("setup", configfile);
setup->Set("ANALYSIS","GRJETSexample_setup");
setup->Set("DEBUG",debug);
chain->Add("ANALYSIS",setup);
Config* example = new Config("example", configfile);
example->Set("ANALYSIS","GRJETSexample");
example->Set("DEBUG",debug);
chain->Add("ANALYSIS",example);
cout << endl << "+++ Using jet types: " << jetTypes << endl << endl;
chain->Set("MCWEIGHTS" , mcweights );
chain->Set("DEBUG" , debug );
chain->Set("PILE" , doPRW );
chain->Set("DOBASIC" , doBasic );
chain->Set("DOTRUTHLINKS" , doTruthLinks );
chain->Set("DOTRACKJETLINKS" , doTrackJetLinks );
chain->Set("DOTRUTHJETLINKS" , doTruthJetLinks );
chain->Set("DOJETSTRUCT" , doJetStructure );
chain->Set("DOCONSTIT" , doConstituents );
chain->Set("DOTRUTHCONSTIT" , doTruthConstit );
chain->Set("DOPARENTCHILD" , doParentChild );
chain->Set("DOTRACK" , doTrack );
chain->Set("DOLCCLUSTER" , doLCCluster );
chain->Set("DOEMCLUSTER" , doEMCluster );
chain->Set("DOTRUTH" , doTruth );
chain->Set("DOVTX" , doVertex );
chain->Set("DOPHOTON" , doPhotons );
/// Set Systematics
chain->Set("DOTRACKSYST" , false );
chain->Set("DOJETSYS" , 0 );
/// Set cuts and jet types and such
chain->Set("BASECUSTOMTRIMMING", baseCustomTrimming);
chain->Set("PTFRACCUSTOMTRIMMING", ptFracCustomTrimming);
chain->Set("SMALLRCUSTOMTRIMMING", smallRCustomTrimming);
chain->Set("JETTYPES" , jetTypes );
chain->Set("SUBJETTYPES" , subjetTypes );
chain->Set("BTAGTYPES" , btagTypes );
chain->Set("BADJETTYPE" , badJetType );
chain->Set("BADJETDEF" , badJetDef );
chain->Set("MINJETPT" , minJetPt );
chain->Set("MAXJETETA" , maxJetEta );
chain->Set("MINFATJETPT" , minFatJetPt );
chain->Set("MAXFATJETETA" , maxJetEta );
chain->Set("MINJETJVF" , minJetJVF );
chain->Set("MAXJETTRKJETDR" , maxJetTrkDR );
chain->Set("MAXTRUTHJETDR" , maxJetTruthDR );
chain->Set("NStdJetCut" , 4 );
chain->Set("LowMassCRcut" , 100. );
chain->Set("ThreeBodyCRcut" , 0.7 );
chain->Set("y12CRcut" , 0.4 );
///----------------------------------------------------------------
/// Trigger Information
///----------------------------------------------------------------
TString trigTypes = "EF_j360_a10tcem";
TString trigParams = "jet_AntiKt10LCTopo_pt";
TString trigCuts = "450000."; /// NEEDS TO BE IN MEV
TString trigLumis = "5725.04"; /// UPDATE ME!
chain->Set("TRIGTYPES" , trigTypes );
chain->Set("TRIGPARAM" , trigParams );
chain->Set("TRIGCUT" , trigCuts );
chain->Set("TRIGLUMI" , trigLumis );
///----------------------------------------------------------------
/// Luminosity for trigger weighting
///----------------------------------------------------------------
Float_t lumiVal = 5725.04;
chain->Set("LUMI" , lumiVal );
chain->Write();
if (chain->Exists("GRL")) WriteGRLObject(chain->String("GRL"));
///----------------------------------------------------------------
/// ProofAna global Config object
///----------------------------------------------------------------
Config* confProofAna = new Config("ProofAna");
confProofAna->Set("DEBUG" , false ); // "false", 0, "0" etc. also works
confProofAna->Set("SAVETIMERS" , false ); // ProofAna timer histos in output file
confProofAna->Set("IDENTIFIER" , identifier );
confProofAna->Set("DATASET" , dataset );
confProofAna->Set("OUTPUTPATH" , path );
confProofAna->Set("EVENTBUILDER" , eventbuilder );
if (!doHists)
confProofAna->Set("MERGE" , false ); // enable dataset mode
///----------------------------------------------------------------
/// Read information used in MC weighting, multi-dataset jobs
///----------------------------------------------------------------
ReadDatasetInfo(dataset , confProofAna );
WriteGroomedPRWO(options , "EF_j360_a10tcem_PeriodB" );
confProofAna->Write();
options->Close();
delete options;
cout << "All setup, ready to go " << endl;
// Decide to run local or on the cluster
if (mode.CompareTo("local") == 0) runLocal(dataset, treename);
else if(mode.CompareTo("lite")==0||mode.CompareTo("cluster")==0)
runProof(url,dataset,-1,treename);
else if(mode.CompareTo("grid")==0){
TString gridname = "user."+gridusername+"."+identifier;
cout << "submitting with gridname " << gridname << endl;
runGrid(gridname);
}
gSystem->Unlink("options.root");
}
/*
* Config builds a set of files for building a UNIX
* system given a description of the desired system.
*/
int
main(int argc, char *argv[])
{
struct stat buf;
int ch, len;
unsigned int i;
char *p;
char linksrc[64], linkdest[MAXPATHLEN];
static const char *emus[] = { "linux" };
while ((ch = getopt(argc, argv, "d:gpr")) != -1)
switch (ch) {
case 'd':
if (*destdir == '\0')
strlcpy(destdir, optarg, sizeof(destdir));
else
errx(2, "directory already set");
break;
case 'g':
debugging++;
break;
case 'p':
profiling++;
break;
case 'r':
no_config_clobber = FALSE;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 1)
usage();
if (freopen(PREFIX = *argv, "r", stdin) == NULL)
err(2, "%s", PREFIX);
if (*destdir != '\0') {
len = strlen(destdir);
while (len > 1 && destdir[len - 1] == '/')
destdir[--len] = '\0';
get_srcdir();
} else {
strlcpy(destdir, CDIR, sizeof(destdir));
strlcat(destdir, PREFIX, sizeof(destdir));
}
p = path(NULL);
if (stat(p, &buf)) {
if (mkdir(p, 0777))
err(2, "%s", p);
}
else if ((buf.st_mode & S_IFMT) != S_IFDIR) {
errx(2, "%s isn't a directory", p);
}
else if (!no_config_clobber) {
char tmp[strlen(p) + 8];
fprintf(stderr, "Removing old directory %s: ", p);
fflush(stderr);
snprintf(tmp, sizeof(tmp), "rm -rf %s", p);
if (system(tmp)) {
fprintf(stderr, "Failed!\n");
err(2, "%s", tmp);
}
fprintf(stderr, "Done.\n");
if (mkdir(p, 0777))
err(2, "%s", p);
}
dtab = NULL;
if (yyparse())
exit(3);
if (platformname == NULL) {
printf("Specify platform architecture, e.g. 'platform pc64'\n");
exit(1);
}
if (machinename == NULL) {
printf("Specify machine architecture, e.g. 'machine x86_64'\n");
exit(1);
}
if (machinearchname == NULL) {
printf("Specify cpu architecture, e.g. 'machine_arch x86_64'\n");
exit(1);
}
newbus_ioconf();
/*
* "machine" points into platform/<PLATFORM>/include
*/
if (*srcdir == '\0')
snprintf(linkdest, sizeof(linkdest), "../../platform/%s/include",
platformname);
else
snprintf(linkdest, sizeof(linkdest), "%s/platform/%s/include",
srcdir, platformname);
symlink(linkdest, path("machine"));
/*
* "machine_base" points into platform/<PLATFORM>
*/
if (*srcdir == '\0')
snprintf(linkdest, sizeof(linkdest), "../../platform/%s",
platformname);
else
snprintf(linkdest, sizeof(linkdest), "%s/platform/%s",
srcdir, platformname);
symlink(linkdest, path("machine_base"));
/*
* "cpu" points to cpu/<MACHINE_ARCH>/include
*/
if (*srcdir == '\0')
snprintf(linkdest, sizeof(linkdest),
"../../cpu/%s/include", machinearchname);
else
snprintf(linkdest, sizeof(linkdest),
"%s/cpu/%s/include", srcdir, machinearchname);
symlink(linkdest, path("cpu"));
/*
* "cpu_base" points to cpu/<MACHINE_ARCH>
*/
if (*srcdir == '\0')
snprintf(linkdest, sizeof(linkdest), "../../cpu/%s",
machinearchname);
else
snprintf(linkdest, sizeof(linkdest), "%s/cpu/%s",
srcdir, machinearchname);
symlink(linkdest, path("cpu_base"));
/*
* XXX check directory structure for architecture subdirectories and
* create the symlinks automatically XXX
*/
for (i = 0; i < sizeof(emus) / sizeof(emus[0]); ++i) {
if (*srcdir == 0) {
snprintf(linkdest, sizeof(linkdest),
"../../emulation/%s/%s",
emus[i], machinearchname);
} else {
snprintf(linkdest, sizeof(linkdest),
"%s/emulation/%s/%s",
srcdir, emus[i], machinearchname);
}
snprintf(linksrc, sizeof(linksrc), "arch_%s", emus[i]);
symlink(linkdest, path(linksrc));
}
options(); /* make options .h files */
makefile(); /* build Makefile */
headers(); /* make a lot of .h files */
configfile(); /* put config file into kernel*/
printf("Kernel build directory is %s\n", p);
exit(EX_OK);
}
void runSusyBkg(TString mode = "cluster", TString identifier = "myTest", TString dataset = "su4.susy1118", TString username = "******", bool mcweights = true, bool sys = true)
{
//options for mode are local, lite, cluster, or grid
LoadLibraries();
//General user run options (now set in run command)
//TString identifier("myTest"); //unique identifier for this job
//TString dataset("test.example"); //dataset name
//TString username("bcbutler"); //username for cluster, not important otherwise
//SetConfig
TString configfile("../config/periodsB-M.config");
// Best to leave alone
TString pathLite("");
TString pathCluster("root://atlprf01.slac.stanford.edu:2094//atlas/output/");
pathCluster.Append(username);
pathCluster.Append("/");
//Determine eventbuilder from dataset name
TString eventbuilder(dataset);
eventbuilder.Remove(0,eventbuilder.Last('.')+1);
//Filename paths, URLs for PROOF running
TString url(mode);
TString path("");
if(mode.CompareTo("lite")==0) {
url = "lite://"; //ROOT 5.32
path = pathLite;
}
else if(mode.CompareTo("cluster")==0) {
url = TString(username+"@atlprf01.slac.stanford.edu");
path = pathCluster;
}
//Make an options file, edit as needed
TFile* options = new TFile("options.root","RECREATE");
//Analyses Configs, change as needed
bool do0Lepton = true;
bool do4Jet = false;
bool do6Jet = false;
bool doSR1 = true;
bool doSR2 = true;
bool doSR3 = true;
bool do1Electron = true;
bool do2Electron = true;
bool do1Muon = true;
bool do2Muon = true;
bool doFakeNu = false; //convert Zmumubb to Znunubb
bool doKillZnunuZbb = false;
bool doDetail = true;
bool doLocHad = false;
bool doPRW = true;
bool doHFT = true;
bool doWriteTrees = eventbuilder.CompareTo("event") ? true : false;
bool noBtagSFs = true;
bool fancyBtagErr = false;
bool truthEB = false;
bool isData = false;
if(dataset.Contains("Egamma_")) {
do0Lepton = false;
do1Muon = false;
do2Muon = false;
isData = true;
}
else if(dataset.Contains("Muons_")) {
do0Lepton = false;
do1Electron = false;
do2Electron = false;
isData = true;
}
else if(dataset.Contains("JetTauEtmiss_")) {
do1Electron = false;
do2Electron = false;
do1Muon = false;
do2Muon = false;
isData = true;
}
if(truthEB) {
if(isData) {
cout << "You are asking to run the truth-based event builder on data?" << endl;
exit(1);
}
//append for truth-only studies, turn of systematics
eventbuilder.Append("_truth");
sys = false;
}
Config* chain = new Config("chain",configfile); //eventbuilder/mcweights flags in chain config
chain->AddVec("ANALYSIS");
chain->Set("MCWEIGHTS",mcweights);
chain->Set("BTAG",2*(!isData));
chain->Set("NOBTAGSF",noBtagSFs);
chain->Set("FANCYBTAGERR",fancyBtagErr);
chain->Set("PILE",doPRW);
chain->Set("HFT",doHFT);
chain->Set("0LEPTON",do0Lepton);
chain->Set("1ELECTRON",do1Electron);
chain->Set("1MUON",do1Muon);
chain->Set("2ELECTRON",do2Electron);
chain->Set("2MUON",do2Muon);
chain->Set("FAKENU",doFakeNu);
chain->Set("KILLZNUNUZBB",doKillZnunuZbb);
chain->Set("LOCHAD",doLocHad);
//chain->Set("DEBUG",true);
Config* nom = new Config("nom");
nom->Set("ANALYSIS","susybkg");
nom->Set("BTAG",1*(!isData));
nom->Set("0LEPTON",do0Lepton);
nom->Set("4JET",do4Jet);
nom->Set("6JET",do6Jet);
nom->Set("SR1",doSR1);
nom->Set("SR2",doSR2);
nom->Set("SR3",doSR3);
nom->Set("1ELECTRON",do1Electron);
nom->Set("1MUON",do1Muon);
nom->Set("2ELECTRON",do2Electron);
nom->Set("2MUON",do2Muon);
nom->Set("DETAIL",doDetail);
nom->Set("WRITETREES",doWriteTrees);
//nom->Set("DEBUG",true);
chain->Add("ANALYSIS",nom);
if(dataset.Contains("JetTauEtmiss_")||dataset.Contains("ttslLAr")) {
Config* larreversed = new Config("larreversed",configfile);
larreversed->Set("ANALYSIS","susybkg");
larreversed->Set("MCWEIGHTS",mcweights);
larreversed->Set("BTAG",0);
larreversed->Set("PILE",doPRW);
larreversed->Set("HFT",doHFT);
larreversed->Set("0LEPTON",do0Lepton);
larreversed->Set("4JET",do4Jet);
larreversed->Set("6JET",do6Jet);
larreversed->Set("SR1",doSR1);
larreversed->Set("SR2",doSR2);
larreversed->Set("SR3",doSR3);
larreversed->Set("1ELECTRON",false);
larreversed->Set("1MUON",false);
larreversed->Set("2ELECTRON",false);
larreversed->Set("2MUON",false);
larreversed->Set("FAKENU",doFakeNu);
larreversed->Set("KILLZNUNUZBB",doKillZnunuZbb);
larreversed->Set("DETAIL",doDetail);
larreversed->Set("LOCHAD",doLocHad);
larreversed->Set("LARVETOREVERSED",true);
larreversed->Set("WRITETREES",doWriteTrees);
//larreversed->Set("DEBUG",true);
larreversed->Write();
}
if(dataset.Contains("Egamma_")||dataset.Contains("Muons_")) {
Config* mmnom = new Config("mmnom");
mmnom->Set("ANALYSIS","susybkg");
mmnom->Set("BTAG",0);
mmnom->Set("0LEPTON",false);
mmnom->Set("4JET",false);
mmnom->Set("6JET",false);
mmnom->Set("SR1",doSR1);
mmnom->Set("SR2",doSR2);
mmnom->Set("SR3",doSR3);
mmnom->Set("1ELECTRON",do1Electron);
mmnom->Set("1MUON",do1Muon);
mmnom->Set("2ELECTRON",false);
mmnom->Set("2MUON",false);
mmnom->Set("DETAIL",doDetail);
mmnom->Set("MM",1);
mmnom->Set("WRITETREES",doWriteTrees);
//mmnom->Set("DEBUG",true);
chain->Add("ANALYSIS",mmnom);
Config* mmsys = new Config("mmsys");
mmsys->Set("ANALYSIS","susybkg");
mmsys->Set("BTAG",0);
mmsys->Set("0LEPTON",false);
mmsys->Set("4JET",false);
mmsys->Set("6JET",false);
mmsys->Set("SR1",doSR1);
mmsys->Set("SR2",doSR2);
mmsys->Set("SR3",doSR3);
mmsys->Set("1ELECTRON",do1Electron);
mmsys->Set("1MUON",do1Muon);
mmsys->Set("2ELECTRON",false);
mmsys->Set("2MUON",false);
mmsys->Set("DETAIL",doDetail);
mmsys->Set("MM",2);
mmsys->Set("WRITETREES",doWriteTrees);
//mmsys->Set("DEBUG",true);
chain->Add("ANALYSIS",mmsys);
Config* mmstat = new Config("mmstat");
mmstat->Set("ANALYSIS","susybkg");
mmstat->Set("BTAG",0);
mmstat->Set("0LEPTON",false);
mmstat->Set("4JET",false);
mmstat->Set("6JET",false);
mmstat->Set("SR1",doSR1);
mmstat->Set("SR2",doSR2);
mmstat->Set("SR3",doSR3);
mmstat->Set("1ELECTRON",do1Electron);
mmstat->Set("1MUON",do1Muon);
mmstat->Set("2ELECTRON",false);
mmstat->Set("2MUON",false);
mmstat->Set("DETAIL",doDetail);
mmstat->Set("MM",3);
mmstat->Set("WRITETREES",doWriteTrees);
//mmstat->Set("DEBUG",true);
chain->Add("ANALYSIS",mmstat);
}
if((!isData)&&(!dataset.Contains("ttslLAr"))&&sys) {
Config* bup = new Config("bup");
bup->Set("ANALYSIS","susybkg");
bup->Set("BTAG",2);
bup->Set("0LEPTON",do0Lepton);
bup->Set("4JET",do4Jet);
bup->Set("6JET",do6Jet);
bup->Set("SR1",doSR1);
bup->Set("SR2",doSR2);
bup->Set("SR3",doSR3);
bup->Set("1ELECTRON",do1Electron);
bup->Set("1MUON",do1Muon);
bup->Set("2ELECTRON",do2Electron);
bup->Set("2MUON",do2Muon);
bup->Set("WRITETREES",doWriteTrees);
//bup->Set("DEBUG",true);
chain->Add("ANALYSIS",bup);
Config* bdown = new Config("bdown");
bdown->Set("ANALYSIS","susybkg");
bdown->Set("BTAG",3);
bdown->Set("0LEPTON",do0Lepton);
bdown->Set("4JET",do4Jet);
bdown->Set("6JET",do6Jet);
bdown->Set("SR1",doSR1);
bdown->Set("SR2",doSR2);
bdown->Set("SR3",doSR3);
bdown->Set("1ELECTRON",do1Electron);
bdown->Set("1MUON",do1Muon);
bdown->Set("2ELECTRON",do2Electron);
bdown->Set("2MUON",do2Muon);
bdown->Set("WRITETREES",doWriteTrees);
//bdown->Set("DEBUG",true);
chain->Add("ANALYSIS",bdown);
Config* cup = new Config("cup");
cup->Set("ANALYSIS","susybkg");
cup->Set("BTAG",4);
cup->Set("0LEPTON",do0Lepton);
cup->Set("4JET",do4Jet);
cup->Set("6JET",do6Jet);
cup->Set("SR1",doSR1);
cup->Set("SR2",doSR2);
cup->Set("SR3",doSR3);
cup->Set("1ELECTRON",do1Electron);
cup->Set("1MUON",do1Muon);
cup->Set("2ELECTRON",do2Electron);
cup->Set("2MUON",do2Muon);
cup->Set("WRITETREES",doWriteTrees);
//cup->Set("DEBUG",true);
chain->Add("ANALYSIS",cup);
Config* cdown = new Config("cdown");
cdown->Set("ANALYSIS","susybkg");
cdown->Set("BTAG",5);
cdown->Set("0LEPTON",do0Lepton);
cdown->Set("4JET",do4Jet);
cdown->Set("6JET",do6Jet);
cdown->Set("SR1",doSR1);
cdown->Set("SR2",doSR2);
cdown->Set("SR3",doSR3);
cdown->Set("1ELECTRON",do1Electron);
cdown->Set("1MUON",do1Muon);
cdown->Set("2ELECTRON",do2Electron);
cdown->Set("2MUON",do2Muon);
cdown->Set("WRITETREES",doWriteTrees);
//cdown->Set("DEBUG",true);
chain->Add("ANALYSIS",cdown);
Config* lup = new Config("lup");
lup->Set("ANALYSIS","susybkg");
lup->Set("BTAG",6);
lup->Set("0LEPTON",do0Lepton);
lup->Set("4JET",do4Jet);
lup->Set("6JET",do6Jet);
lup->Set("SR1",doSR1);
lup->Set("SR2",doSR2);
lup->Set("SR3",doSR3);
lup->Set("1ELECTRON",do1Electron);
lup->Set("1MUON",do1Muon);
lup->Set("2ELECTRON",do2Electron);
lup->Set("2MUON",do2Muon);
lup->Set("WRITETREES",doWriteTrees);
//lup->Set("DEBUG",true);
chain->Add("ANALYSIS",lup);
Config* ldown = new Config("ldown");
ldown->Set("ANALYSIS","susybkg");
ldown->Set("BTAG",7);
ldown->Set("0LEPTON",do0Lepton);
ldown->Set("4JET",do4Jet);
ldown->Set("6JET",do6Jet);
ldown->Set("SR1",doSR1);
ldown->Set("SR2",doSR2);
ldown->Set("SR3",doSR3);
ldown->Set("1ELECTRON",do1Electron);
ldown->Set("1MUON",do1Muon);
ldown->Set("2ELECTRON",do2Electron);
ldown->Set("2MUON",do2Muon);
ldown->Set("WRITETREES",doWriteTrees);
//ldown->Set("DEBUG",true);
chain->Add("ANALYSIS",ldown);
if(fancyBtagErr) {
for(int i = 0; i<4; ++i) {
for(int j = 0; j<1; ++j) {
Config* bstat_up = new Config(TString::Format("bup_%i_%i",i+1,j+1));
bstat_up->Set("ANALYSIS","susybkg");
bstat_up->Set("BTAG",8);
bstat_up->Set("BTAGFLAVOR",0);
bstat_up->Set("BTAGDIR",0);
bstat_up->Set("BTAGPTBIN",i+1);
bstat_up->Set("BTAGETABIN",j+1);
bstat_up->Set("0LEPTON",do0Lepton);
bstat_up->Set("4JET",do4Jet);
bstat_up->Set("6JET",do6Jet);
bstat_up->Set("SR1",doSR1);
bstat_up->Set("SR2",doSR2);
bstat_up->Set("SR3",doSR3);
bstat_up->Set("1ELECTRON",do1Electron);
bstat_up->Set("1MUON",do1Muon);
bstat_up->Set("2ELECTRON",do2Electron);
bstat_up->Set("2MUON",do2Muon);
bstat_up->Set("WRITETREES",doWriteTrees);
//bstat_up->Set("DEBUG",true);
chain->Add("ANALYSIS",bstat_up);
Config* bstat_down = new Config(TString::Format("bdown_%i_%i",i+1,j+1));
bstat_down->Set("ANALYSIS","susybkg");
bstat_down->Set("BTAG",8);
bstat_down->Set("BTAGFLAVOR",0);
bstat_down->Set("BTAGDIR",1);
bstat_down->Set("BTAGPTBIN",i+1);
bstat_down->Set("BTAGETABIN",j+1);
bstat_down->Set("0LEPTON",do0Lepton);
bstat_down->Set("4JET",do4Jet);
bstat_down->Set("6JET",do6Jet);
bstat_down->Set("SR1",doSR1);
bstat_down->Set("SR2",doSR2);
bstat_down->Set("SR3",doSR3);
bstat_down->Set("1ELECTRON",do1Electron);
bstat_down->Set("1MUON",do1Muon);
bstat_down->Set("2ELECTRON",do2Electron);
bstat_down->Set("2MUON",do2Muon);
bstat_down->Set("WRITETREES",doWriteTrees);
//bstat_down->Set("DEBUG",true);
chain->Add("ANALYSIS",bstat_down);
}
}
for(int i = 0; i<1; ++i) {
for(int j = 0; j<1; ++j) {
Config* cstat_up = new Config(TString::Format("cup_%i_%i",i+1,j+1));
cstat_up->Set("ANALYSIS","susybkg");
cstat_up->Set("BTAG",8);
cstat_up->Set("BTAGFLAVOR",1);
cstat_up->Set("BTAGDIR",0);
cstat_up->Set("BTAGPTBIN",i+1);
cstat_up->Set("BTAGETABIN",j+1);
cstat_up->Set("0LEPTON",do0Lepton);
cstat_up->Set("4JET",do4Jet);
cstat_up->Set("6JET",do6Jet);
cstat_up->Set("SR1",doSR1);
cstat_up->Set("SR2",doSR2);
cstat_up->Set("SR3",doSR3);
cstat_up->Set("1ELECTRON",do1Electron);
cstat_up->Set("1MUON",do1Muon);
cstat_up->Set("2ELECTRON",do2Electron);
cstat_up->Set("2MUON",do2Muon);
cstat_up->Set("WRITETREES",doWriteTrees);
//cstat_up->Set("DEBUG",true);
chain->Add("ANALYSIS",cstat_up);
Config* cstat_down = new Config(TString::Format("cdown_%i_%i",i+1,j+1));
cstat_down->Set("ANALYSIS","susybkg");
cstat_down->Set("BTAG",8);
cstat_down->Set("BTAGFLAVOR",1);
cstat_down->Set("BTAGDIR",1);
cstat_down->Set("BTAGPTBIN",i+1);
cstat_down->Set("BTAGETABIN",j+1);
cstat_down->Set("0LEPTON",do0Lepton);
cstat_down->Set("4JET",do4Jet);
cstat_down->Set("6JET",do6Jet);
cstat_down->Set("SR1",doSR1);
cstat_down->Set("SR2",doSR2);
cstat_down->Set("SR3",doSR3);
cstat_down->Set("1ELECTRON",do1Electron);
cstat_down->Set("1MUON",do1Muon);
cstat_down->Set("2ELECTRON",do2Electron);
cstat_down->Set("2MUON",do2Muon);
cstat_down->Set("WRITETREES",doWriteTrees);
//cstat_down->Set("DEBUG",true);
chain->Add("ANALYSIS",cstat_down);
}
}
for(int i = 0; i<1; ++i) {
for(int j = 0; j<1; ++j) {
Config* lstat_up = new Config(TString::Format("lup_%i_%i",i+1,j+1));
lstat_up->Set("ANALYSIS","susybkg");
lstat_up->Set("BTAG",8);
lstat_up->Set("BTAGFLAVOR",2);
lstat_up->Set("BTAGDIR",0);
lstat_up->Set("BTAGPTBIN",i+1);
lstat_up->Set("BTAGETABIN",j+1);
lstat_up->Set("0LEPTON",do0Lepton);
lstat_up->Set("4JET",do4Jet);
lstat_up->Set("6JET",do6Jet);
lstat_up->Set("SR1",doSR1);
lstat_up->Set("SR2",doSR2);
lstat_up->Set("SR3",doSR3);
lstat_up->Set("1ELECTRON",do1Electron);
lstat_up->Set("1MUON",do1Muon);
lstat_up->Set("2ELECTRON",do2Electron);
lstat_up->Set("2MUON",do2Muon);
lstat_up->Set("WRITETREES",doWriteTrees);
//lstat_up->Set("DEBUG",true);
chain->Add("ANALYSIS",lstat_up);
Config* lstat_down = new Config(TString::Format("ldown_%i_%i",i+1,j+1));
lstat_down->Set("ANALYSIS","susybkg");
lstat_down->Set("BTAG",8);
lstat_down->Set("BTAGFLAVOR",2);
lstat_down->Set("BTAGDIR",1);
lstat_down->Set("BTAGPTBIN",i+1);
lstat_down->Set("BTAGETABIN",j+1);
lstat_down->Set("0LEPTON",do0Lepton);
lstat_down->Set("4JET",do4Jet);
lstat_down->Set("6JET",do6Jet);
lstat_down->Set("SR1",doSR1);
lstat_down->Set("SR2",doSR2);
lstat_down->Set("SR3",doSR3);
lstat_down->Set("1ELECTRON",do1Electron);
lstat_down->Set("1MUON",do1Muon);
lstat_down->Set("2ELECTRON",do2Electron);
lstat_down->Set("2MUON",do2Muon);
lstat_down->Set("WRITETREES",doWriteTrees);
//lstat_down->Set("DEBUG",true);
chain->Add("ANALYSIS",lstat_down);
}
}
}
Config* jesup = new Config("jesup",configfile);
jesup->Set("ANALYSIS","susybkg");
jesup->Set("MCWEIGHTS",mcweights);
jesup->Set("JETSYS",1);
jesup->Set("BTAG",1);
jesup->Set("NOBTAGSF",noBtagSFs);
jesup->Set("PILE",doPRW);
jesup->Set("HFT",doHFT);
jesup->Set("0LEPTON",do0Lepton);
jesup->Set("4JET",do4Jet);
jesup->Set("6JET",do6Jet);
jesup->Set("SR1",doSR1);
jesup->Set("SR2",doSR2);
jesup->Set("SR3",doSR3);
jesup->Set("1ELECTRON",do1Electron);
jesup->Set("1MUON",do1Muon);
jesup->Set("2ELECTRON",do2Electron);
jesup->Set("2MUON",do2Muon);
jesup->Set("FAKENU",doFakeNu);
jesup->Set("KILLZNUNUZBB",doKillZnunuZbb);
jesup->Set("WRITETREES",doWriteTrees);
jesup->Write();
Config* jesdown = new Config("jesdown",configfile);
jesdown->Set("ANALYSIS","susybkg");
jesdown->Set("MCWEIGHTS",mcweights);
jesdown->Set("JETSYS",2);
jesdown->Set("BTAG",1);
jesdown->Set("NOBTAGSF",noBtagSFs);
jesdown->Set("PILE",doPRW);
jesdown->Set("HFT",doHFT);
jesdown->Set("0LEPTON",do0Lepton);
jesdown->Set("4JET",do4Jet);
jesdown->Set("6JET",do6Jet);
jesdown->Set("SR1",doSR1);
jesdown->Set("SR2",doSR2);
jesdown->Set("SR3",doSR3);
jesdown->Set("1ELECTRON",do1Electron);
jesdown->Set("1MUON",do1Muon);
jesdown->Set("2ELECTRON",do2Electron);
jesdown->Set("2MUON",do2Muon);
jesdown->Set("FAKENU",doFakeNu);
jesdown->Set("KILLZNUNUZBB",doKillZnunuZbb);
jesdown->Set("WRITETREES",doWriteTrees);
jesdown->Write();
Config* jer = new Config("jer",configfile);
jer->Set("ANALYSIS","susybkg");
jer->Set("MCWEIGHTS",mcweights);
jer->Set("JETSYS",3);
jer->Set("BTAG",1);
jer->Set("NOBTAGSF",noBtagSFs);
jer->Set("PILE",doPRW);
jer->Set("HFT",doHFT);
jer->Set("0LEPTON",do0Lepton);
jer->Set("4JET",do4Jet);
jer->Set("6JET",do6Jet);
jer->Set("SR1",doSR1);
jer->Set("SR2",doSR2);
jer->Set("SR3",doSR3);
jer->Set("1ELECTRON",do1Electron);
jer->Set("1MUON",do1Muon);
jer->Set("2ELECTRON",do2Electron);
jer->Set("2MUON",do2Muon);
jer->Set("FAKENU",doFakeNu);
jer->Set("KILLZNUNUZBB",doKillZnunuZbb);
jer->Set("WRITETREES",doWriteTrees);
jer->Write();
Config* scalestup = new Config("scalestup",configfile);
scalestup->Set("ANALYSIS","susybkg");
scalestup->Set("MCWEIGHTS",mcweights);
scalestup->Set("METSYS",1);
scalestup->Set("BTAG",1);
scalestup->Set("NOBTAGSF",noBtagSFs);
scalestup->Set("PILE",doPRW);
scalestup->Set("HFT",doHFT);
scalestup->Set("0LEPTON",do0Lepton);
scalestup->Set("4JET",do4Jet);
scalestup->Set("6JET",do6Jet);
scalestup->Set("SR1",doSR1);
scalestup->Set("SR2",doSR2);
scalestup->Set("SR3",doSR3);
scalestup->Set("1ELECTRON",do1Electron);
scalestup->Set("1MUON",do1Muon);
scalestup->Set("2ELECTRON",do2Electron);
scalestup->Set("2MUON",do2Muon);
scalestup->Set("FAKENU",doFakeNu);
scalestup->Set("KILLZNUNUZBB",doKillZnunuZbb);
scalestup->Set("WRITETREES",doWriteTrees);
scalestup->Write();
Config* scalestdown = new Config("scalestdown",configfile);
scalestdown->Set("ANALYSIS","susybkg");
scalestdown->Set("MCWEIGHTS",mcweights);
scalestdown->Set("METSYS",2);
scalestdown->Set("BTAG",1);
scalestdown->Set("NOBTAGSF",noBtagSFs);
scalestdown->Set("PILE",doPRW);
scalestdown->Set("HFT",doHFT);
scalestdown->Set("0LEPTON",do0Lepton);
scalestdown->Set("4JET",do4Jet);
scalestdown->Set("6JET",do6Jet);
scalestdown->Set("SR1",doSR1);
scalestdown->Set("SR2",doSR2);
scalestdown->Set("SR3",doSR3);
scalestdown->Set("1ELECTRON",do1Electron);
scalestdown->Set("1MUON",do1Muon);
scalestdown->Set("2ELECTRON",do2Electron);
scalestdown->Set("2MUON",do2Muon);
scalestdown->Set("FAKENU",doFakeNu);
scalestdown->Set("KILLZNUNUZBB",doKillZnunuZbb);
scalestdown->Set("WRITETREES",doWriteTrees);
scalestdown->Write();
Config* resostup = new Config("resostup",configfile);
resostup->Set("ANALYSIS","susybkg");
resostup->Set("MCWEIGHTS",mcweights);
resostup->Set("METSYS",3);
resostup->Set("BTAG",1);
resostup->Set("NOBTAGSF",noBtagSFs);
resostup->Set("PILE",doPRW);
resostup->Set("HFT",doHFT);
resostup->Set("0LEPTON",do0Lepton);
resostup->Set("4JET",do4Jet);
resostup->Set("6JET",do6Jet);
resostup->Set("SR1",doSR1);
resostup->Set("SR2",doSR2);
resostup->Set("SR3",doSR3);
resostup->Set("1ELECTRON",do1Electron);
resostup->Set("1MUON",do1Muon);
resostup->Set("2ELECTRON",do2Electron);
resostup->Set("2MUON",do2Muon);
resostup->Set("FAKENU",doFakeNu);
resostup->Set("KILLZNUNUZBB",doKillZnunuZbb);
resostup->Set("WRITETREES",doWriteTrees);
resostup->Write();
Config* resostdown = new Config("resostdown",configfile);
resostdown->Set("ANALYSIS","susybkg");
resostdown->Set("MCWEIGHTS",mcweights);
resostdown->Set("METSYS",4);
resostdown->Set("BTAG",1);
resostdown->Set("NOBTAGSF",noBtagSFs);
resostdown->Set("PILE",doPRW);
resostdown->Set("HFT",doHFT);
resostdown->Set("0LEPTON",do0Lepton);
resostdown->Set("4JET",do4Jet);
resostdown->Set("6JET",do6Jet);
resostdown->Set("SR1",doSR1);
resostdown->Set("SR2",doSR2);
resostdown->Set("SR3",doSR3);
resostdown->Set("1ELECTRON",do1Electron);
resostdown->Set("1MUON",do1Muon);
resostdown->Set("2ELECTRON",do2Electron);
resostdown->Set("2MUON",do2Muon);
resostdown->Set("FAKENU",doFakeNu);
resostdown->Set("KILLZNUNUZBB",doKillZnunuZbb);
resostdown->Set("WRITETREES",doWriteTrees);
resostdown->Write();
}
//Write chain (nominal analysis + b-tagging systematics/matrix method, identical eventbuilder result, just reweighted)
chain->Write();
//ProofAna global Config object
Config* confProofAna = new Config("ProofAna");
//confProofAna->Set("DEBUG",true); // "false", 0, "0" etc. also works
//confProofAna->Set("MERGE",false); // enable dataset mode
//confProofAna->Set("NFILES",1000000); // how many input files to merge per worker in dataset mode, very large number = 49 output files
confProofAna->Set("SAVETIMERS",false); // ProofAna timer histograms in output file
//confProofAna->Set("COUNTER",1);
confProofAna->Set("IDENTIFIER",identifier);
confProofAna->Set("DATASET",dataset);
confProofAna->Set("OUTPUTPATH",path);
confProofAna->Set("EVENTBUILDER",eventbuilder);
ReadDatasetInfo(dataset,confProofAna); //Reads information used in MC weighting, multi-dataset jobs
TString treename;
if(!confProofAna->Get("TREENAME",treename)) {
cout << "TREENAME not set in dataset config file, exiting" << endl;
return;
}
confProofAna->Write();
bool isAF2 = false;
confProofAna->Get("AF2",isAF2);
WriteSUSYObjDefObject(options, isData, isAF2);
WriteGRLObject(chain->String("GRL"));
WriteMuonTrigReweighterObjects(options);
WriteMuonTriggerSFToolObject(options);
//WriteMultijetJESUncertaintyObject(options);
//WriteBTagCalibObject(options,"SV0","5_85");
//WriteBTagCalibObject(options,"JetFitterCOMBNN","1_80");
//WriteBTagCalibObject(options,"JetFitterCOMBNN","0_35");
//WriteBTagCalibObject(options,"JetFitterCOMBNN","-1_25");
WriteBTagCalibObject(options,"MV1","0_905363");
WriteBTagCalibObject(options,"MV1","0_601713");
WriteBTagCalibObject(options,"MV1","0_404219");
//WriteJERObject(options);
Write0LeptonPileupReweightingObject(options);
Write1ElectronPileupReweightingObject(options);
Write1MuonPileupReweightingObject(options);
WriteFakeMetEstimator(options);
WriteSmearingReweightHist(options);
WriteElectronMMObject(options);
options->Close();
delete options;
if(mode.CompareTo("local")==0) runLocal(dataset,treename);
else if(mode.CompareTo("grid")==0) {
TString prefix = "user."+username+"."+identifier;
runGrid(prefix);
}
else runProof(url,dataset,-1,treename);
gSystem->Unlink("options.root");
}
bool OSCParams::Load(void) {
m_bSetList = 0;
ReadConfigFile configfile(OSCParams::staticCallbackFunction, this);
return configfile.Read(PARAMS_FILE_NAME);
}
int main( int argc, char ** argv )
{
// Register custom message handler if desired
bool handler_registered = FALSE;
MyMessageOutput * mymsghandler = NULL;
for(int i = 1; i < argc; i++)
{
QString arg(argv[i]);
QString opt("-msg_handler");
if(arg.startsWith(opt))
{
// Extract handler type
QString handler = arg.section("=",1,1);
if(handler.isEmpty())
{
qWarning("Option '-msg_handler' is not complete. Use default handler.");
handler_registered = TRUE;
break;
}
if(handler == "console")
{
handler_registered = TRUE;
break;
}
if(!handler.endsWith(".txt"))
{
qWarning("File '%s' does not end with '.txt'. Use default handler.",handler.ascii());
handler_registered = TRUE;
break;
}
QFileInfo hfinfo(handler);
if(hfinfo.exists())
{
if(!hfinfo.isWritable())
{
qWarning("Cannot write to '%s'. Use default handler",handler.ascii());
handler_registered = TRUE;
break;
}
}
else
{
QString path = hfinfo.dirPath();
QFileInfo hfdinfo(path);
if(!hfdinfo.isWritable())
{
qWarning("Cannot create file in dir '%s'. Use default handler",path.ascii());
handler_registered = TRUE;
break;
}
}
mymsghandler = new MyMessageOutput(handler);
handler_registered = TRUE;
break;
}
}
if(!handler_registered)
{
mymsghandler = new MyMessageOutput(QString("debuglog.txt"));
handler_registered = TRUE;
}
#ifdef Q_WS_X11
if(XInitThreads() == 0)
qFatal("XInitThreads didn't succeed");
#endif
// Create a QApplication object and add default close
QApplication a( argc, argv );
a.connect( &a, SIGNAL( lastWindowClosed() ), &a, SLOT( quit() ) );
// Start the configuration selection dialog if more than one config file is available
ConfigSelector cs;
if(cs.getNumConfigs() > 1)
{
cs.resize(300,150);
cs.show();
a.exec();
}
// Load configuration
Configuration * config = new Configuration();
QString configfile(cs.getConfig());
if(!config->load(configfile))
{
qFatal("Unable to load %s", configfile.ascii());
}
ConfigNode * cn = config->getConfig();
if(!cn)
{
qFatal("Unable to get ConfigNode");
}
ApplicationNode * an = cn->getApplicationNode();
if(!an)
{
qFatal("Unable to get ApplicationNode");
}
PluginsNode * pn = cn->getPluginsNode();
if(!pn)
{
qFatal("Unable to get PluginsNode");
}
OBJECTVALUENODE_DECLARE_AND_GET(QPoint,position,an);
OBJECTVALUENODE_DECLARE_AND_GET(QSize,size,an);
SIMPLEVALUENODE_DECLARE_AND_GET(bool,maximized,an);
SIMPLEVALUENODE_DECLARE_AND_GET(Q_INT8,tbindex,an);
// Create the toplevel window
Q3HBox * w = new Q3HBox();
w->setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Preferred);
// Add a widget that contains the toolbox and measurements
Q3VBox * pVBox = new Q3VBox( w );
pVBox->setSizePolicy( QSizePolicy::Fixed, QSizePolicy::Preferred );
pVBox->setSpacing( 5 );
pVBox->setMargin( 2 );
// Create the toolbox
QToolBox * tb = new QToolBox( pVBox );
// Create all plugins
Plugin * VisualizePlugin = new Plugin("visualize");
Plugin * AnalysePlugin = new Plugin("analyse_os");
Plugin * WaveInPlugin = new Plugin("wavein");
Plugin * FileWriterPlugin = new Plugin("filewriter");
// Load plugin objects
PI_Unknown *ukvi = VisualizePlugin->getObject();
PI_Unknown *ukan = AnalysePlugin->getObject();
PI_Unknown *ukwi = WaveInPlugin->getObject();
PI_Unknown *ukfw = FileWriterPlugin->getObject();
// Configure the system
if( ukvi && ukan && ukwi && ukfw )
{
PI_GuiContainer* gcwiobj = NULL;
PI_GuiContainer* gcviobj = NULL;
PI_GuiContainer* gcfwobj = NULL;
PI_Configuration* xcanobj = NULL;
PI_Configuration* xcviobj = NULL;
PI_Configuration* xcwiobj = NULL;
PI_Configuration* xcfwobj = NULL;
PI_DataBufferProvider* dbpwiobj = NULL;
PI_DataBufferProvider* dbpanobj = NULL;
PI_DataBufferConsumer* dbcanobj = NULL;
PI_DataBufferConsumer* dbcviobj = NULL;
PI_DataBufferConsumer* dbcfwobj = NULL;
PI_TimeProvider* tpwiobj = NULL;
PI_TimeConsumer* tcviobj = NULL;
PI_TimeConsumer* tcfwobj = NULL;
ukwi->queryInterface( PIID_GUI_CONTAINER, (void**)&gcwiobj );
ukvi->queryInterface( PIID_GUI_CONTAINER , (void**)&gcviobj );
ukfw->queryInterface( PIID_GUI_CONTAINER, (void**)&gcfwobj );
ukan->queryInterface( PIID_CONFIGURATION, (void**)&xcanobj );
ukvi->queryInterface( PIID_CONFIGURATION, (void**)&xcviobj );
ukwi->queryInterface( PIID_CONFIGURATION, (void**)&xcwiobj );
ukfw->queryInterface( PIID_CONFIGURATION, (void**)&xcfwobj );
ukwi->queryInterface( PIID_DATA_BUFFER_PROVIDER, (void**)&dbpwiobj );
ukan->queryInterface( PIID_DATA_BUFFER_PROVIDER, (void**)&dbpanobj );
ukan->queryInterface( PIID_DATA_BUFFER_CONSUMER, (void**)&dbcanobj );
ukvi->queryInterface( PIID_DATA_BUFFER_CONSUMER, (void**)&dbcviobj );
ukfw->queryInterface( PIID_DATA_BUFFER_CONSUMER, (void**)&dbcfwobj );
ukwi->queryInterface( PIID_TIME_PROVIDER, (void**)&tpwiobj );
ukvi->queryInterface( PIID_TIME_CONSUMER, (void**)&tcviobj );
ukfw->queryInterface( PIID_TIME_CONSUMER, (void**)&tcfwobj );
if( gcwiobj && gcviobj && gcfwobj &&
xcwiobj && xcanobj && xcviobj && xcfwobj &&
dbpwiobj && dbpanobj && dbcanobj && dbcviobj && dbcfwobj &&
tpwiobj && tcviobj && tcfwobj)
{
// Wave in object
gcwiobj->setParentWindow( tb, "WaveDeviceConfiguration" );
// Visualize object
gcviobj->setParentWindow( tb, "Diagram1" );
gcviobj->setParentWindow( tb, "Diagram2" );
gcviobj->setParentWindow( tb, "Diagram3" );
gcviobj->setParentWindow( tb, "Diagram4" );
gcviobj->setParentWindow( tb, "Diagram5" );
gcviobj->setParentWindow( tb, "Configuration" );
gcviobj->setParentWindow( tb, "BaseFrequency" );
gcviobj->setParentWindow( pVBox, "TopDisplay" );
gcviobj->setParentWindow( w, "Graph" );
// File writer object
gcfwobj->setParentWindow( tb, "SpectralDataSaveGui" );
// Wave in object
PLUGINNODE_DECLARE_AND_GET(wavein,pn);
xcwiobj->configure(NODE_VARIABLE_NAME(wavein));
// Analyse object
PLUGINNODE_DECLARE_AND_GET(analyse,pn);
xcanobj->configure(NODE_VARIABLE_NAME(analyse));
// Visualize object
PLUGINNODE_DECLARE_AND_GET(visualize,pn);
xcviobj->configure(NODE_VARIABLE_NAME(visualize));
// File writer object
PLUGINNODE_DECLARE_AND_GET(filewriter,pn);
xcfwobj->configure(NODE_VARIABLE_NAME(filewriter));
// Connect the 'pause' source to different sinks
gcviobj->connectSlot( "pause", gcwiobj->getObject("WaveDeviceConfiguration"), "setPause" );
gcviobj->connectSlot( "pause", gcfwobj->getObject("SpectralDataSaveGui"), "setPause" );
// Add visualize object configurations to the toolbox
tb->addItem( gcviobj->getWidget("Diagram1"), "Diagramm 1" );
tb->addItem( gcviobj->getWidget("Diagram2"), "Diagramm 2" );
tb->addItem( gcviobj->getWidget("Diagram3"), "Diagramm 3" );
tb->addItem( gcviobj->getWidget("Diagram4"), "Diagramm 4" );
tb->addItem( gcviobj->getWidget("Diagram5"), "Diagramm 5" );
tb->addItem( gcviobj->getWidget("Configuration"), "Konfiguration" );
tb->addItem( gcviobj->getWidget("BaseFrequency"), "Bezugston, Stimmung" );
// Add file writer object configuration to the toolbox
tb->addItem( gcfwobj->getWidget("SpectralDataSaveGui"), "Datenspeicherung" );
// Add wave in object configuration to the toolbox
tb->addItem( gcwiobj->getWidget("WaveDeviceConfiguration"), "Soundkarte" );
dbpwiobj->addRef();
dbcanobj->connectToProvider( dbpwiobj );
dbpanobj->addRef();
dbcviobj->connectToProvider( dbpanobj );
dbpwiobj->addRef();
dbcfwobj->connectToProvider( dbpwiobj ); //filewrite
dbpanobj->addRef();
dbcfwobj->connectToProvider( dbpanobj ); //filewrite
tpwiobj->addRef();
tcviobj->connectToProvider( tpwiobj );
tpwiobj->addRef();
tcfwobj->connectToProvider( tpwiobj ); //filewrite
xcwiobj->startRunning();
xcanobj->startRunning();
xcviobj->startRunning();
xcfwobj->startRunning(); //filewrite
}
if( gcwiobj ) gcwiobj->release();
if( gcviobj ) gcviobj->release();
if( gcfwobj ) gcfwobj->release();
if( xcanobj ) xcanobj->release();
if( xcviobj ) xcviobj->release();
if( xcwiobj ) xcwiobj->release();
if( xcfwobj ) xcfwobj->release();
if( dbpwiobj ) dbpwiobj->release();
if( dbpanobj ) dbpanobj->release();
if( dbcanobj ) dbcanobj->release();
if( dbcviobj ) dbcviobj->release();
if( dbcfwobj ) dbcfwobj->release();
if( tpwiobj ) tpwiobj->release();
if( tcviobj ) tcviobj->release();
if( tcfwobj ) tcfwobj->release();
}
// Set active item in the ToolBox
tb->setCurrentIndex(VALUENODE_GET_VALUE(tbindex));
w->resize(VALUENODE_GET_VALUE(size));
w->move(VALUENODE_GET_VALUE(position));
if(VALUENODE_GET_VALUE(maximized))
w->showMaximized();
w->setCaption("Prisma-Realtime v1.3b");
w->show();
Q3Accel *esc = new Q3Accel( w );
esc->connectItem( esc->insertItem( Qt::Key_Escape ), &a, SLOT( quit() ) );
a.exec();
w->hide();
if(!w->isMaximized())
{
VALUENODE_SET_VALUE(size,w->size());
VALUENODE_SET_VALUE(position,w->pos());
}
VALUENODE_SET_VALUE(maximized,w->isMaximized());
VALUENODE_SET_VALUE(tbindex,tb->currentIndex());
if( ukvi && ukan && ukwi && ukfw )
{
PI_Configuration * xmlconfig = NULL;
ukvi->queryInterface(PIID_CONFIGURATION, (void**)&xmlconfig);
if(xmlconfig != NULL)
{
xmlconfig->stopRunning();
xmlconfig->release();
xmlconfig = NULL;
}
ukan->queryInterface(PIID_CONFIGURATION, (void**)&xmlconfig);
if(xmlconfig != NULL)
{
xmlconfig->stopRunning();
xmlconfig->release();
xmlconfig = NULL;
}
ukwi->queryInterface(PIID_CONFIGURATION, (void**)&xmlconfig);
if(xmlconfig != NULL)
{
xmlconfig->stopRunning();
xmlconfig->release();
xmlconfig = NULL;
}
ukfw->queryInterface(PIID_CONFIGURATION, (void**)&xmlconfig);
if(xmlconfig != NULL)
{
xmlconfig->stopRunning();
xmlconfig->release();
xmlconfig = NULL;
}
}
if(ukvi) ukvi->release();
if(ukan) ukan->release();
if(ukwi) ukwi->release();
if(ukfw) ukfw->release();
delete w;
config->save(configfile);
// Delete before unloading plugins!!!
delete config;
// Release plugins
delete VisualizePlugin;
delete FileWriterPlugin;
delete AnalysePlugin;
delete WaveInPlugin;
if(mymsghandler)
delete mymsghandler;
return 0;
}
bool CFlashUpdate::checkVersion4Update()
{
if(g_settings.softupdate_mode==1) //internet-update
{
if(!getInfo())
{
hide();
ShowHint("messagebox.error", g_Locale->getText("flashupdate.getinfofileerror") );
return false;
}
showLocalStatus(100);
showGlobalStatus(20);
showStatusMessage(g_Locale->getText("flashupdate.versioncheck").c_str());
string sFileName = gTmpPath+VersionFile;
CConfigFile configfile('\t');
if(!configfile.loadConfig(sFileName))
{
ShowHint ( "messagebox.error", g_Locale->getText("flashupdate.getinfofileerror") );
return false;
}
else
{
newVersion = configfile.getString( "version", "" );
if(newVersion=="")
{
ShowHint ( "messagebox.error", g_Locale->getText("flashupdate.getinfofileerror") );
return false;
}
}
printf("internet version: %s\n", newVersion.c_str());
if(newVersion==installedVersion)
{
ShowHint ( "messagebox.error", g_Locale->getText("flashupdate.nonewversion") );
return false;
}
}
else
{
//manuelles update -- filecheck + abfrage
FILE* fd = fopen((string(gTmpPath+ ImageFile)).c_str(), "r");
if(fd)
{
fclose(fd);
}
else
{
hide();
printf("flash-file not found: %s\n", (string(gTmpPath+ ImageFile)).c_str() );
ShowHint ( "messagebox.error", g_Locale->getText("flashupdate.cantopenfile") );
return false;
}
hide();
//bestimmung der CramfsDaten
char cramfsName[30];
cramfs_name( (char*) (string(gTmpPath+ImageFile)).c_str(), (char*) &cramfsName);
CFlashVersionInfo versionInfo(cramfsName);
char msg[400];
sprintf( (char*) &msg, g_Locale->getText("flashupdate.msgbox_manual").c_str(), versionInfo.getDate().c_str(),
versionInfo.getTime().c_str(), versionInfo.getBaseImageVersion().c_str(), versionInfo.getType().c_str() );
if ( ShowMsg ( "messagebox.info", msg, CMessageBox::mbrYes, CMessageBox::mbYes | CMessageBox::mbNo, "softupdate.raw" ) != CMessageBox::mbrYes )
{
return false;
}
return true;
}
showLocalStatus(100);
showGlobalStatus(20);
hide();
//bestimmung der CramfsDaten
CFlashVersionInfo versionInfo(newVersion);
char msg[250];
sprintf( (char*) &msg, g_Locale->getText("flashupdate.msgbox").c_str(), versionInfo.getDate().c_str(),
versionInfo.getTime().c_str(), versionInfo.getBaseImageVersion().c_str(), versionInfo.getType().c_str() );
if ( ShowMsg ( "messagebox.info", msg, CMessageBox::mbrYes, CMessageBox::mbYes | CMessageBox::mbNo, "softupdate.raw" ) != CMessageBox::mbrYes )
{
return false;
}
return true;
}
int
main(int argc, char **argv)
{
struct bsdtar *bsdtar;
int opt;
char possible_help_request;
char buff[16];
char cachedir[PATH_MAX + 1];
struct passwd *pws;
char *conffile;
const char *missingkey;
time_t now;
size_t i;
WARNP_INIT;
/* Use a pointer for consistency. */
bsdtar = bsdtar_init();
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure open() function will be used with a binary mode. */
/* on cygwin, we need something similar, but instead link against */
/* a special startup object, binmode.o */
_set_fmode(_O_BINARY);
#endif
/* Need bsdtar->progname before calling bsdtar_warnc. */
if (*argv == NULL)
bsdtar->progname = "tarsnap";
else {
#if defined(_WIN32) && !defined(__CYGWIN__)
bsdtar->progname = strrchr(*argv, '\\');
#else
bsdtar->progname = strrchr(*argv, '/');
#endif
if (bsdtar->progname != NULL)
bsdtar->progname++;
else
bsdtar->progname = *argv;
}
/* We don't have a machine # yet. */
bsdtar->machinenum = (uint64_t)(-1);
/* Allocate space for archive names; at most argc of them. */
if ((bsdtar->tapenames = malloc(argc * sizeof(const char *))) == NULL)
bsdtar_errc(bsdtar, 1, ENOMEM, "Cannot allocate memory");
bsdtar->ntapes = 0;
/* Allocate space for config file names; at most argc of them. */
if ((bsdtar->configfiles = malloc(argc * sizeof(const char *))) == NULL)
bsdtar_errc(bsdtar, 1, ENOMEM, "Cannot allocate memory");
bsdtar->nconfigfiles = 0;
time(&now);
bsdtar->creationtime = now;
if (setlocale(LC_ALL, "") == NULL)
bsdtar_warnc(bsdtar, 0, "Failed to set default locale");
#if defined(HAVE_NL_LANGINFO) && defined(HAVE_D_MD_ORDER)
bsdtar->day_first = (*nl_langinfo(D_MD_ORDER) == 'd');
#endif
possible_help_request = 0;
/* Initialize key cache. We don't have any keys yet. */
if (crypto_keys_init())
exit(1);
/*
* Make stdout line-buffered (if possible) so that operations such as
* "tarsnap --list-archives | more" will run more smoothly. The only
* downside to this is a slight performance cost; but we don't write
* enough data to stdout for that to matter.
*/
setvbuf(stdout, NULL, _IONBF, 0);
/*
* Unless specified otherwise, we consider ourselves to be
* constructing a snapshot of the disk as it is right now.
*/
/*
* POSIX doesn't provide any mechanism for distinguishing between
* an error and the time (time_t)(-1). Since we only use this to
* avoid race conditions in the chunkification cache (i.e., so
* that we can determine if a file has been modified since it was
* last backed up), and hopefully nobody will have any files with
* negative last-modified dates, an error return of (-1) can be
* handled the same was as a legitimate return of (-1): Nothing
* gets cached.
*/
bsdtar->snaptime = time(NULL);
/* Store original argument vector. */
bsdtar->argc_orig = argc;
bsdtar->argv_orig = argv;
/* Look up the current user and his home directory. */
if ((pws = getpwuid(geteuid())) != NULL)
if ((bsdtar->homedir = strdup(pws->pw_dir)) == NULL)
bsdtar_errc(bsdtar, 1, ENOMEM, "Cannot allocate memory");
/* Look up uid of current user for future reference */
bsdtar->user_uid = geteuid();
/* Default: preserve mod time on extract */
bsdtar->extract_flags = ARCHIVE_EXTRACT_TIME;
/* Default: Perform basic security checks. */
bsdtar->extract_flags |= SECURITY;
/* Defaults for root user: */
if (bsdtar_is_privileged(bsdtar)) {
/* --same-owner */
bsdtar->extract_flags |= ARCHIVE_EXTRACT_OWNER;
/* -p */
bsdtar->extract_flags |= ARCHIVE_EXTRACT_PERM;
bsdtar->extract_flags |= ARCHIVE_EXTRACT_ACL;
bsdtar->extract_flags |= ARCHIVE_EXTRACT_XATTR;
bsdtar->extract_flags |= ARCHIVE_EXTRACT_FFLAGS;
}
bsdtar->argv = argv;
bsdtar->argc = argc;
/* We gather some options in a 'delayed options queue'. */
bsdtar->delopt = NULL;
bsdtar->delopt_tail = &bsdtar->delopt;
/*
* Comments following each option indicate where that option
* originated: SUSv2, POSIX, GNU tar, star, etc. If there's
* no such comment, then I don't know of anyone else who
* implements that option.
*/
while ((opt = bsdtar_getopt(bsdtar)) != -1) {
switch (opt) {
case OPTION_AGGRESSIVE_NETWORKING: /* tarsnap */
optq_push(bsdtar, "aggressive-networking", NULL);
break;
case 'B': /* GNU tar */
/* libarchive doesn't need this; just ignore it. */
break;
case 'C': /* GNU tar */
if (strlen(bsdtar->optarg) == 0)
bsdtar_errc(bsdtar, 1, 0,
"Meaningless option: -C ''");
set_chdir(bsdtar, bsdtar->optarg);
break;
case 'c': /* SUSv2 */
set_mode(bsdtar, opt, "-c");
break;
case OPTION_CACHEDIR: /* multitar */
optq_push(bsdtar, "cachedir", bsdtar->optarg);
break;
case OPTION_CHECK_LINKS: /* GNU tar */
bsdtar->option_warn_links = 1;
break;
case OPTION_CHECKPOINT_BYTES: /* tarsnap */
optq_push(bsdtar, "checkpoint-bytes", bsdtar->optarg);
break;
case OPTION_CHROOT: /* NetBSD */
bsdtar->option_chroot = 1;
break;
case OPTION_CONFIGFILE:
bsdtar->configfiles[bsdtar->nconfigfiles++] =
bsdtar->optarg;
break;
case OPTION_CREATIONTIME: /* tarsnap */
errno = 0;
bsdtar->creationtime = strtol(bsdtar->optarg,
NULL, 0);
if ((errno) || (bsdtar->creationtime == 0))
bsdtar_errc(bsdtar, 1, 0,
"Invalid --creationtime argument: %s",
bsdtar->optarg);
break;
case OPTION_CSV_FILE: /* tarsnap */
if (bsdtar->option_csv_filename != NULL)
bsdtar_errc(bsdtar, 1, errno,
"Two --csv-file options given.\n");
if ((bsdtar->option_csv_filename = strdup(
bsdtar->optarg)) == NULL)
bsdtar_errc(bsdtar, 1, errno, "Out of memory");
break;
case 'd': /* multitar */
set_mode(bsdtar, opt, "-d");
break;
case OPTION_DISK_PAUSE: /* tarsnap */
optq_push(bsdtar, "disk-pause", bsdtar->optarg);
break;
case OPTION_DRYRUN: /* tarsnap */
bsdtar->option_dryrun = 1;
break;
case OPTION_EXCLUDE: /* GNU tar */
optq_push(bsdtar, "exclude", bsdtar->optarg);
break;
case 'f': /* multitar */
bsdtar->tapenames[bsdtar->ntapes++] = bsdtar->optarg;
break;
case OPTION_FSCK: /* multitar */
set_mode(bsdtar, opt, "--fsck");
break;
case OPTION_FSCK_PRUNE: /* multitar */
set_mode(bsdtar, opt, "--fsck-prune");
break;
case 'H': /* BSD convention */
bsdtar->symlink_mode = 'H';
break;
case 'h': /* Linux Standards Base, gtar; synonym for -L */
bsdtar->symlink_mode = 'L';
/* Hack: -h by itself is the "help" command. */
possible_help_request = 1;
break;
case OPTION_HELP: /* GNU tar, others */
long_help(bsdtar);
exit(0);
break;
case OPTION_HUMANIZE_NUMBERS: /* tarsnap */
optq_push(bsdtar, "humanize-numbers", NULL);
break;
case 'I': /* GNU tar */
/*
* TODO: Allow 'names' to come from an archive,
* not just a text file. Design a good UI for
* allowing names and mode/owner to be read
* from an archive, with contents coming from
* disk. This can be used to "refresh" an
* archive or to design archives with special
* permissions without having to create those
* permissions on disk.
*/
bsdtar->names_from_file = bsdtar->optarg;
break;
case OPTION_INCLUDE:
optq_push(bsdtar, "include", bsdtar->optarg);
break;
case OPTION_INSANE_FILESYSTEMS:
optq_push(bsdtar, "insane-filesystems", NULL);
break;
case 'k': /* GNU tar */
bsdtar->extract_flags |= ARCHIVE_EXTRACT_NO_OVERWRITE;
break;
case OPTION_KEEP_GOING: /* tarsnap */
bsdtar->option_keep_going = 1;
break;
case OPTION_KEEP_NEWER_FILES: /* GNU tar */
bsdtar->extract_flags |= ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER;
break;
case OPTION_KEYFILE: /* tarsnap */
optq_push(bsdtar, "keyfile", bsdtar->optarg);
break;
case 'L': /* BSD convention */
bsdtar->symlink_mode = 'L';
break;
case 'l': /* SUSv2 and GNU tar beginning with 1.16 */
/* GNU tar 1.13 used -l for --one-file-system */
bsdtar->option_warn_links = 1;
break;
case OPTION_LIST_ARCHIVES: /* multitar */
set_mode(bsdtar, opt, "--list-archives");
break;
case OPTION_LOWMEM: /* tarsnap */
optq_push(bsdtar, "lowmem", NULL);
break;
case 'm': /* SUSv2 */
bsdtar->extract_flags &= ~ARCHIVE_EXTRACT_TIME;
break;
case OPTION_MAXBW: /* tarsnap */
optq_push(bsdtar, "maxbw", bsdtar->optarg);
break;
case OPTION_MAXBW_RATE: /* tarsnap */
optq_push(bsdtar, "maxbw-rate", bsdtar->optarg);
break;
case OPTION_MAXBW_RATE_DOWN: /* tarsnap */
optq_push(bsdtar, "maxbw-rate-down", bsdtar->optarg);
break;
case OPTION_MAXBW_RATE_UP: /* tarsnap */
optq_push(bsdtar, "maxbw-rate-up", bsdtar->optarg);
break;
case 'n': /* GNU tar */
bsdtar->option_no_subdirs = 1;
break;
/*
* Selecting files by time:
* --newer-?time='date' Only files newer than 'date'
* --newer-?time-than='file' Only files newer than time
* on specified file (useful for incremental backups)
* TODO: Add corresponding "older" options to reverse these.
*/
case OPTION_NEWER_CTIME: /* GNU tar */
bsdtar->newer_ctime_sec = get_date(now, bsdtar->optarg);
break;
case OPTION_NEWER_CTIME_THAN:
{
struct stat st;
if (stat(bsdtar->optarg, &st) != 0)
bsdtar_errc(bsdtar, 1, 0,
"Can't open file %s", bsdtar->optarg);
bsdtar->newer_ctime_sec = st.st_ctime;
bsdtar->newer_ctime_nsec =
ARCHIVE_STAT_CTIME_NANOS(&st);
}
break;
case OPTION_NEWER_MTIME: /* GNU tar */
bsdtar->newer_mtime_sec = get_date(now, bsdtar->optarg);
break;
case OPTION_NEWER_MTIME_THAN:
{
struct stat st;
if (stat(bsdtar->optarg, &st) != 0)
bsdtar_errc(bsdtar, 1, 0,
"Can't open file %s", bsdtar->optarg);
bsdtar->newer_mtime_sec = st.st_mtime;
bsdtar->newer_mtime_nsec =
ARCHIVE_STAT_MTIME_NANOS(&st);
}
break;
case OPTION_NODUMP: /* star */
optq_push(bsdtar, "nodump", NULL);
break;
case OPTION_NOISY_WARNINGS: /* tarsnap */
tarsnap_opt_noisy_warnings = 1;
break;
case OPTION_NORMALMEM:
optq_push(bsdtar, "normalmem", NULL);
break;
case OPTION_NO_AGGRESSIVE_NETWORKING:
optq_push(bsdtar, "no-aggressive-networking", NULL);
break;
case OPTION_NO_CONFIG_EXCLUDE:
optq_push(bsdtar, "no-config-exclude", NULL);
break;
case OPTION_NO_CONFIG_INCLUDE:
optq_push(bsdtar, "no-config-include", NULL);
break;
case OPTION_NO_DEFAULT_CONFIG:
bsdtar->option_no_default_config = 1;
break;
case OPTION_NO_DISK_PAUSE:
optq_push(bsdtar, "no-disk-pause", NULL);
break;
case OPTION_NO_HUMANIZE_NUMBERS:
optq_push(bsdtar, "no-humanize-numbers", NULL);
break;
case OPTION_NO_INSANE_FILESYSTEMS:
optq_push(bsdtar, "no-insane-filesystems", NULL);
break;
case OPTION_NO_MAXBW:
optq_push(bsdtar, "no-maxbw", NULL);
break;
case OPTION_NO_MAXBW_RATE_DOWN:
optq_push(bsdtar, "no-maxbw-rate-down", NULL);
break;
case OPTION_NO_MAXBW_RATE_UP:
optq_push(bsdtar, "no-maxbw-rate-up", NULL);
break;
case OPTION_NO_NODUMP:
optq_push(bsdtar, "no-nodump", NULL);
break;
case OPTION_NO_PRINT_STATS:
optq_push(bsdtar, "no-print-stats", NULL);
break;
case OPTION_NO_QUIET:
optq_push(bsdtar, "no-quiet", NULL);
break;
case OPTION_NO_RETRY_FOREVER:
optq_push(bsdtar, "no-retry-forever", NULL);
break;
case OPTION_NO_SAME_OWNER: /* GNU tar */
bsdtar->extract_flags &= ~ARCHIVE_EXTRACT_OWNER;
break;
case OPTION_NO_SAME_PERMISSIONS: /* GNU tar */
bsdtar->extract_flags &= ~ARCHIVE_EXTRACT_PERM;
bsdtar->extract_flags &= ~ARCHIVE_EXTRACT_ACL;
bsdtar->extract_flags &= ~ARCHIVE_EXTRACT_XATTR;
bsdtar->extract_flags &= ~ARCHIVE_EXTRACT_FFLAGS;
break;
case OPTION_NO_SNAPTIME:
optq_push(bsdtar, "no-snaptime", NULL);
break;
case OPTION_NO_STORE_ATIME:
optq_push(bsdtar, "no-store-atime", NULL);
break;
case OPTION_NO_TOTALS:
optq_push(bsdtar, "no-totals", NULL);
break;
case OPTION_NUKE: /* tarsnap */
set_mode(bsdtar, opt, "--nuke");
break;
case OPTION_NULL: /* GNU tar */
bsdtar->option_null++;
break;
case OPTION_NUMERIC_OWNER: /* GNU tar */
bsdtar->option_numeric_owner++;
break;
case 'O': /* GNU tar */
bsdtar->option_stdout = 1;
break;
case 'o':
bsdtar->option_no_owner = 1;
bsdtar->extract_flags &= ~ARCHIVE_EXTRACT_OWNER;
break;
case OPTION_ONE_FILE_SYSTEM: /* GNU tar */
bsdtar->option_dont_traverse_mounts = 1;
break;
case 'P': /* GNU tar */
bsdtar->extract_flags &= ~SECURITY;
bsdtar->option_absolute_paths = 1;
break;
case 'p': /* GNU tar, star */
bsdtar->extract_flags |= ARCHIVE_EXTRACT_PERM;
bsdtar->extract_flags |= ARCHIVE_EXTRACT_ACL;
bsdtar->extract_flags |= ARCHIVE_EXTRACT_XATTR;
bsdtar->extract_flags |= ARCHIVE_EXTRACT_FFLAGS;
break;
case OPTION_PRINT_STATS: /* multitar */
bsdtar->option_print_stats = 1;
break;
case 'q': /* FreeBSD GNU tar --fast-read, NetBSD -q */
bsdtar->option_fast_read = 1;
break;
case OPTION_QUIET:
optq_push(bsdtar, "quiet", NULL);
break;
case 'r': /* multitar */
set_mode(bsdtar, opt, "-r");
break;
case OPTION_RECOVER:
set_mode(bsdtar, opt, "--recover");
break;
case OPTION_RETRY_FOREVER:
optq_push(bsdtar, "retry-forever", NULL);
break;
case OPTION_SNAPTIME: /* multitar */
optq_push(bsdtar, "snaptime", bsdtar->optarg);
break;
case OPTION_STORE_ATIME: /* multitar */
optq_push(bsdtar, "store-atime", NULL);
break;
case 'S': /* NetBSD pax-as-tar */
bsdtar->extract_flags |= ARCHIVE_EXTRACT_SPARSE;
break;
case 's': /* NetBSD pax-as-tar */
#if HAVE_REGEX_H
add_substitution(bsdtar, bsdtar->optarg);
#else
bsdtar_warnc(bsdtar, 0,
"-s is not supported by this version of tarsnap");
usage(bsdtar);
#endif
break;
case OPTION_SAME_OWNER: /* GNU tar */
bsdtar->extract_flags |= ARCHIVE_EXTRACT_OWNER;
break;
case OPTION_STRIP_COMPONENTS: /* GNU tar 1.15 */
errno = 0;
bsdtar->strip_components = strtol(bsdtar->optarg,
NULL, 0);
if (errno)
bsdtar_errc(bsdtar, 1, 0,
"Invalid --strip-components argument: %s",
bsdtar->optarg);
break;
case 'T': /* GNU tar */
bsdtar->names_from_file = bsdtar->optarg;
break;
case 't': /* SUSv2 */
set_mode(bsdtar, opt, "-t");
bsdtar->verbose++;
break;
case OPTION_TOTALS: /* GNU tar */
optq_push(bsdtar, "totals", NULL);
break;
case 'U': /* GNU tar */
bsdtar->extract_flags |= ARCHIVE_EXTRACT_UNLINK;
bsdtar->option_unlink_first = 1;
break;
case 'v': /* SUSv2 */
bsdtar->verbose++;
break;
case OPTION_VERSION: /* GNU convention */
version();
break;
case OPTION_VERYLOWMEM: /* tarsnap */
optq_push(bsdtar, "verylowmem", NULL);
break;
#if 0
/*
* The -W longopt feature is handled inside of
* bsdtar_getopt(), so -W is not available here.
*/
case 'W': /* Obscure GNU convention. */
break;
#endif
case 'w': /* SUSv2 */
bsdtar->option_interactive = 1;
break;
case 'X': /* GNU tar */
if (exclude_from_file(bsdtar, bsdtar->optarg))
bsdtar_errc(bsdtar, 1, 0,
"failed to process exclusions from file %s",
bsdtar->optarg);
break;
case 'x': /* SUSv2 */
set_mode(bsdtar, opt, "-x");
break;
default:
usage(bsdtar);
}
}
/*
* Sanity-check options.
*/
/*
* If --print-stats was specified but no mode was set, then
* --print-stats *is* the mode.
*/
if ((bsdtar->mode == '\0') && (bsdtar->option_print_stats == 1))
set_mode(bsdtar, OPTION_PRINT_STATS, "--print-stats");
/* If no "real" mode was specified, treat -h as --help. */
if ((bsdtar->mode == '\0') && possible_help_request) {
long_help(bsdtar);
exit(0);
}
/*
* If we're doing a dry run and the user hasn't specified an archive
* name via -f, use a fake name. This will result in the statistics
* printed by --print-stats being a few bytes off, since the archive
* name is included in the metadata block... but we're going to be a
* few bytes off anyway since the command line, including "--dry-run"
* is included in the metadata.
*/
if (bsdtar->option_dryrun && (bsdtar->ntapes == 0))
bsdtar->tapenames[bsdtar->ntapes++] = "(dry-run)";
/* At this point we must have a mode set. */
if (bsdtar->mode == '\0')
bsdtar_errc(bsdtar, 1, 0,
"Must specify one of -c, -d, -r, -t, -x,"
" --list-archives, --print-stats,"
" --fsck, --fsck-prune, or --nuke");
/* Process "delayed" command-line options which we queued earlier. */
while (bsdtar->delopt != NULL) {
dooption(bsdtar, bsdtar->delopt->opt_name,
bsdtar->delopt->opt_arg, 0);
optq_pop(bsdtar);
}
/* Process config files passed on the command line. */
for (i = 0; i < bsdtar->nconfigfiles; i++)
configfile(bsdtar, bsdtar->configfiles[i]);
/* If we do not have --no-default-config, process default configs. */
if (bsdtar->option_no_default_config == 0) {
/* Process options from ~/.tarsnaprc. */
if (bsdtar->homedir != NULL) {
if (asprintf(&conffile, "%s/.tarsnaprc",
bsdtar->homedir) == -1)
bsdtar_errc(bsdtar, 1, errno, "No memory");
configfile(bsdtar, conffile);
/* Free string allocated by asprintf. */
free(conffile);
}
/* Process options from system-wide tarsnap.conf. */
configfile(bsdtar, ETC_TARSNAP_CONF);
}
/* Continue with more sanity-checking. */
if ((bsdtar->ntapes == 0) &&
(bsdtar->mode != OPTION_PRINT_STATS &&
bsdtar->mode != OPTION_LIST_ARCHIVES &&
bsdtar->mode != OPTION_RECOVER &&
bsdtar->mode != OPTION_FSCK &&
bsdtar->mode != OPTION_FSCK_PRUNE &&
bsdtar->mode != OPTION_NUKE))
bsdtar_errc(bsdtar, 1, 0,
"Archive name must be specified");
if ((bsdtar->ntapes > 1) &&
(bsdtar->mode != OPTION_PRINT_STATS &&
bsdtar->mode != 'd'))
bsdtar_errc(bsdtar, 1, 0,
"Option -f may only be specified once in mode %s",
bsdtar->modestr);
if ((bsdtar->mode == 'c') &&
(strlen(bsdtar->tapenames[0]) > 1023))
bsdtar_errc(bsdtar, 1, 0,
"Cannot create an archive with a name > 1023 characters");
if ((bsdtar->mode == 'c') &&
(strlen(bsdtar->tapenames[0]) == 0))
bsdtar_errc(bsdtar, 1, 0,
"Cannot create an archive with an empty name");
if ((bsdtar->cachedir == NULL) &&
(((bsdtar->mode == 'c') && (!bsdtar->option_dryrun)) ||
bsdtar->mode == 'd' ||
bsdtar->mode == OPTION_RECOVER ||
bsdtar->mode == OPTION_FSCK ||
bsdtar->mode == OPTION_FSCK_PRUNE ||
bsdtar->mode == OPTION_PRINT_STATS))
bsdtar_errc(bsdtar, 1, 0,
"Cache directory must be specified for %s",
bsdtar->modestr);
if (tarsnap_opt_aggressive_networking != 0) {
if ((bsdtar->bwlimit_rate_up != 0) ||
(bsdtar->bwlimit_rate_down != 0)) {
bsdtar_warnc(bsdtar, 0,
"--aggressive-networking is incompatible with"
" --maxbw-rate options;\n"
" disabling --aggressive-networking");
tarsnap_opt_aggressive_networking = 0;
}
}
/*
* The -f option doesn't make sense for --list-archives, --fsck,
* --fsck-prune, or --nuke.
*/
if ((bsdtar->ntapes > 0) &&
(bsdtar->mode != OPTION_PRINT_STATS))
only_mode(bsdtar, "-f", "cxtdr");
/*
* These options don't make sense for the "delete" and "convert to
* tar" modes.
*/
if (bsdtar->pending_chdir)
only_mode(bsdtar, "-C", "cxt");
if (bsdtar->names_from_file)
only_mode(bsdtar, "-T", "cxt");
if (bsdtar->newer_ctime_sec || bsdtar->newer_ctime_nsec)
only_mode(bsdtar, "--newer", "cxt");
if (bsdtar->newer_mtime_sec || bsdtar->newer_mtime_nsec)
only_mode(bsdtar, "--newer-mtime", "cxt");
if (bsdtar->option_absolute_paths)
only_mode(bsdtar, "-P", "cxt");
if (bsdtar->option_null)
only_mode(bsdtar, "--null", "cxt");
/* Check options only permitted in certain modes. */
if (bsdtar->option_dont_traverse_mounts)
only_mode(bsdtar, "--one-file-system", "c");
if (bsdtar->option_fast_read)
only_mode(bsdtar, "--fast-read", "xt");
if (bsdtar->option_no_subdirs)
only_mode(bsdtar, "-n", "c");
if (bsdtar->option_no_owner)
only_mode(bsdtar, "-o", "x");
if (bsdtar->option_stdout)
only_mode(bsdtar, "-O", "xt");
if (bsdtar->option_unlink_first)
only_mode(bsdtar, "-U", "x");
if (bsdtar->option_warn_links)
only_mode(bsdtar, "--check-links", "c");
if (bsdtar->option_dryrun)
only_mode(bsdtar, "--dry-run", "c");
/* Check other parameters only permitted in certain modes. */
if (bsdtar->symlink_mode != '\0') {
strcpy(buff, "-?");
buff[1] = bsdtar->symlink_mode;
only_mode(bsdtar, buff, "c");
}
if (bsdtar->strip_components != 0)
only_mode(bsdtar, "--strip-components", "xt");
/*
* If the keyfile in the config file is invalid but we're doing a
* dryrun, continue anyway (and don't use a cachedir).
*/
if (bsdtar->config_file_keyfile_failed && bsdtar->option_dryrun &&
bsdtar->cachedir != NULL) {
bsdtar_warnc(bsdtar, 0,
"Ignoring cachedir due to missing or invalid "
"keyfile in config file.");
free(bsdtar->cachedir);
bsdtar->cachedir = NULL;
}
/*
* Canonicalize the path to the cache directories. This is
* necessary since the tar code can change directories.
*/
if (bsdtar->cachedir != NULL) {
build_dir(bsdtar, bsdtar->cachedir, "--cachedir");
if (realpath(bsdtar->cachedir, cachedir) == NULL)
bsdtar_errc(bsdtar, 1, errno, "realpath(%s)",
bsdtar->cachedir);
free(bsdtar->cachedir);
if ((bsdtar->cachedir = strdup(cachedir)) == NULL)
bsdtar_errc(bsdtar, 1, errno, "Out of memory");
}
/* If we're running --fsck, figure out which key to use. */
if (bsdtar->mode == OPTION_FSCK) {
if (crypto_keys_missing(CRYPTO_KEYMASK_AUTH_PUT) == NULL)
bsdtar->mode = OPTION_FSCK_WRITE;
else if (crypto_keys_missing(CRYPTO_KEYMASK_AUTH_DELETE) == NULL)
bsdtar->mode = OPTION_FSCK_DELETE;
else
bsdtar_errc(bsdtar, 1, 0,
"The write or delete authorization key is"
" required for --fsck but is not available");
}
/* If we're running --recover, figure out which key to use. */
if (bsdtar->mode == OPTION_RECOVER) {
if (crypto_keys_missing(CRYPTO_KEYMASK_AUTH_PUT) == NULL)
bsdtar->mode = OPTION_RECOVER_WRITE;
else if (crypto_keys_missing(CRYPTO_KEYMASK_AUTH_DELETE) == NULL)
bsdtar->mode = OPTION_RECOVER_DELETE;
else
bsdtar_errc(bsdtar, 1, 0,
"The write or delete authorization key is"
" required for --recover but is not available");
}
/* Make sure we have whatever keys we're going to need. */
if (bsdtar->have_keys == 0) {
if (!bsdtar->option_dryrun) {
bsdtar_errc(bsdtar, 1, 0,
"Keys must be provided via --keyfile option");
} else {
if (bsdtar->cachedir != NULL) {
bsdtar_errc(bsdtar, 1, 0,
"Option mismatch for --dry-run: cachedir"
" specified but no keyfile");
}
if (crypto_keys_generate(CRYPTO_KEYMASK_USER))
bsdtar_errc(bsdtar, 1, 0,
"Error generating keys");
if (bsdtar->option_print_stats)
bsdtar_warnc(bsdtar, 0,
"Performing dry-run archival without keys\n"
" (sizes may be slightly "
"inaccurate)");
}
}
missingkey = NULL;
switch (bsdtar->mode) {
case 'c':
if (argv_has_archive_directive(bsdtar))
missingkey = crypto_keys_missing(CRYPTO_KEYMASK_WRITE | CRYPTO_KEYMASK_READ);
else
missingkey = crypto_keys_missing(CRYPTO_KEYMASK_WRITE);
break;
case OPTION_RECOVER_WRITE:
missingkey = crypto_keys_missing(CRYPTO_KEYMASK_WRITE);
break;
case 'd':
case OPTION_FSCK_PRUNE:
case OPTION_FSCK_DELETE:
missingkey = crypto_keys_missing(CRYPTO_KEYMASK_READ |
CRYPTO_KEYMASK_AUTH_DELETE);
break;
case OPTION_FSCK_WRITE:
missingkey = crypto_keys_missing(CRYPTO_KEYMASK_READ |
CRYPTO_KEYMASK_AUTH_PUT);
break;
case OPTION_NUKE:
case OPTION_RECOVER_DELETE:
missingkey = crypto_keys_missing(CRYPTO_KEYMASK_AUTH_DELETE);
break;
case OPTION_PRINT_STATS:
/* We don't need keys for printing global stats. */
if (bsdtar->ntapes == 0)
break;
/* FALLTHROUGH */
case OPTION_LIST_ARCHIVES:
case 'r':
case 't':
case 'x':
missingkey = crypto_keys_missing(CRYPTO_KEYMASK_READ);
break;
}
if (missingkey != NULL)
bsdtar_errc(bsdtar, 1, 0,
"The %s key is required for %s but is not available",
missingkey, bsdtar->modestr);
/* Tell the network layer how much bandwidth to use. */
if (bsdtar->bwlimit_rate_up == 0)
bsdtar->bwlimit_rate_up = 1000000000.;
if (bsdtar->bwlimit_rate_down == 0)
bsdtar->bwlimit_rate_down = 1000000000.;
network_bwlimit(bsdtar->bwlimit_rate_down, bsdtar->bwlimit_rate_up);
/* Perform the requested operation. */
switch(bsdtar->mode) {
case 'c':
tarsnap_mode_c(bsdtar);
break;
case 'd':
tarsnap_mode_d(bsdtar);
break;
case OPTION_FSCK_DELETE:
tarsnap_mode_fsck(bsdtar, 0, 1);
break;
case OPTION_FSCK_PRUNE:
tarsnap_mode_fsck(bsdtar, 1, 1);
break;
case OPTION_FSCK_WRITE:
tarsnap_mode_fsck(bsdtar, 0, 0);
break;
case OPTION_PRINT_STATS:
tarsnap_mode_print_stats(bsdtar);
break;
case OPTION_RECOVER_DELETE:
tarsnap_mode_recover(bsdtar, 1);
break;
case OPTION_RECOVER_WRITE:
tarsnap_mode_recover(bsdtar, 0);
break;
case OPTION_LIST_ARCHIVES:
tarsnap_mode_list_archives(bsdtar);
break;
case OPTION_NUKE:
tarsnap_mode_nuke(bsdtar);
break;
case 'r':
tarsnap_mode_r(bsdtar);
break;
case 't':
tarsnap_mode_t(bsdtar);
break;
case 'x':
tarsnap_mode_x(bsdtar);
break;
}
#ifdef DEBUG_SELECTSTATS
double N, mu, va, max;
network_getselectstats(&N, &mu, &va, &max);
fprintf(stderr, "Time-between-select-calls statistics:\n");
fprintf(stderr, "N = %6g mu = %12g ms "
"va = %12g ms^2 max = %12g ms\n",
N, mu * 1000, va * 1000000, max * 1000);
#endif
#ifdef PROFILE
/*
* If we're compiling with profiling turned on, chdir to a directory
* into which we're likely to be able to write to before exiting.
*/
if (bsdtar->cachedir != NULL)
chdir(cachedir);
#endif
if (bsdtar->return_value != 0)
bsdtar_warnc(bsdtar, 0,
"Error exit delayed from previous errors.");
return (bsdtar->return_value);
}
int main(int argc, char *argv[])
{
try
{
edmplugin::PluginManager::configure(edmplugin::standard::config());
}
catch (cms::Exception& e)
{
edm::LogInfo("DDCompareCPV") << "Attempting to configure the plugin manager. Exception message: " << e.what();
return 1;
}
// Process the command line arguments
std::string descString("DDCompareCPV");
descString += " [options] configurationFileName1 configurationFileName2 Compares two DDCompactViews\n";
descString += "Allowed options";
boost::program_options::options_description desc(descString);
desc.add_options()
("help,h", "Print this help message")
("file1,f", boost::program_options::value<std::string>(), "XML configuration file name. "
"Default is DetectorDescription/RegressionTest/test/configuration.xml")
("file2,g", boost::program_options::value<std::string>(), "XML configuration file name. "
"Default is DetectorDescription/RegressionTest/test/configuration.xml")
("dist-tolerance,t", boost::program_options::value<std::string>(), "Value tolerance for distances (in mm). "
"Default value 0.0004 (anything larger is an error)")
("rot-tolerance,r", boost::program_options::value<std::string>(), "Value tolerance for rotation matrix elements. "
"Default value is 0.0004 (anything larger is an error)")
("spec-tolerance,s", boost::program_options::value<std::string>(), "Value tolerance for rotation matrix elements. "
"Default value is 0.0004 (anything larger is an error) NOT USED YET")
("user-ns,u", "Use the namespaces in each file and do NOT use the filename as namespace. "
"Default is to use the filename of each file in the configuration.xml file as a filename")
("comp-rot,c", "Use the rotation name when comparing rotations. "
"Default is to use the matrix only and not the name when comparing DDRotations")
("continue-on-error,e", "Continue after an error in values. "
"Default is to stop at the first error. NOT IMPLEMENTED")
("attempt-resync,a", "Continue after an error in graph position, attempt to resync. "
"Default is to stop at the first mis-match of the graph. NOT IMPLEMENTED");
boost::program_options::positional_options_description p;
p.add("file1", 1);
p.add("file2", 2);
boost::program_options::variables_map vm;
try {
store(boost::program_options::command_line_parser(argc,argv).options(desc).positional(p).run(),vm);
notify(vm);
} catch(boost::program_options::error const& iException) {
std::cerr << "Exception from command line processing: "
<< iException.what() << "\n";
std::cerr << desc << std::endl;
return 1;
}
if(vm.count("help")) {
std::cout << desc << std::endl;
return 0;
}
bool fullPath = false;
std::string configfile("DetectorDescription/RegressionTest/test/configuration.xml");
std::string configfile2("DetectorDescription/RegressionTest/test/configuration.xml");
DDCompOptions ddco;
// double dtol(0.0004), rottol(0.0004);
// bool usrns(false), comprot(false);
bool usrns(false);
try {
if (vm.count("file1")) {
configfile = vm["file1"].as<std::string>();
if (vm.count("file2")) {
configfile2 = vm["file2"].as<std::string>();
}
}
if (vm.count("dist-tolerance"))
ddco.distTol_ = vm["dist-tolerance"].as<double>();
if (vm.count("rot-tolerance"))
ddco.rotTol_ = vm["rot-tolerance"].as<double>();
if (vm.count("spec-tolerance"))
ddco.rotTol_ = vm["spec-tolerance"].as<double>();
if (vm.count("user-ns"))
usrns = true;
if (vm.count("comp-rot"))
ddco.compRotName_ = true;
if (vm.count("continue-on-error"))
ddco.contOnError_ = true;
if (vm.count("attempt-resync"))
ddco.attResync_ = true;
}
catch(boost::exception& e)
{
edm::LogInfo("DDCompareCPV") << "Attempting to parse the options. Exception message: " << boost::diagnostic_information(e);
return 1;
}
std::ios_base::fmtflags originalFlags = std::cout.flags();
std::cout << "Settings are: " << std::endl;
std::cout << "Configuration file 1: " << configfile << std::endl;
std::cout << "Configuration file 2: " << configfile2 << std::endl;
std::cout << "Length/distance tolerance: " << ddco.distTol_ << std::endl;
std::cout << "Rotation matrix element tolerance: " << ddco.rotTol_ << std::endl;
std::cout << "SpecPar tolerance: " << ddco.specTol_ << std::endl;
std::cout << "User controlled namespace (both file sets)? " << std::boolalpha << usrns << std::endl;
std::cout << "Compare Rotation names? " << ddco.compRotName_ << std::endl;
std::cout << "Continue on error (data mismatch)? " << ddco.contOnError_ << std::endl;
std::cout << "Attempt resyncronization of disparate graphs? " << ddco.attResync_ << std::endl;
DDCompactView cpv1;
DDLParser myP(cpv1);
myP.getDDLSAX2FileHandler()->setUserNS(usrns);
/* The configuration file tells the parser what to parse.
The sequence of files to be parsed does not matter but for one exception:
XML containing SpecPar-tags must be parsed AFTER all corresponding
PosPart-tags were parsed. (Simply put all SpecPars-tags into seperate
files and mention them at end of configuration.xml. Functional SW
will not suffer from this restriction).
*/
// Use the File-In-Path configuration document provider.
FIPConfiguration fp(cpv1);
try
{
fp.readConfig(configfile, fullPath);
}
catch (cms::Exception& e)
{
edm::LogInfo("DDCompareCPV") << "Attempting to read config. Exception message: " << e.what();
return 1;
}
std::cout << "FILE 1: " << configfile << std::endl;
if ( fp.getFileList().size() == 0 ) {
std::cout << "FILE 1: configuration file has no DDD xml files in it!" << std::endl;
exit(1);
}
int parserResult = myP.parse(fp);
if (parserResult != 0) {
std::cout << "FILE 1: problem encountered during parsing. exiting ... " << std::endl;
exit(1);
}
cpv1.lockdown();
DDCompactView cpv2;
DDLParser myP2(cpv2);
myP2.getDDLSAX2FileHandler()->setUserNS(usrns);
/* The configuration file tells the parser what to parse.
The sequence of files to be parsed does not matter but for one exception:
XML containing SpecPar-tags must be parsed AFTER all corresponding
PosPart-tags were parsed. (Simply put all SpecPars-tags into seperate
files and mention them at end of configuration.xml. Functional SW
will not suffer from this restriction).
*/
// Use the File-In-Path configuration document provider.
FIPConfiguration fp2(cpv2);
fp2.readConfig(configfile2, fullPath);
std::cout << "FILE 2: " << configfile2 << std::endl;
if ( fp2.getFileList().size() == 0 ) {
std::cout << "FILE 2: configuration file has no DDD xml files in it!" << std::endl;
exit(1);
}
int parserResult2 = myP2.parse(fp2);
if (parserResult2 != 0) {
std::cout << "FILE 2: problem encountered during parsing. exiting ... " << std::endl;
exit(1);
}
cpv2.lockdown();
std::cout << "Parsing completed. Start comparing." << std::endl;
// DDErrorDetection ed(cpv1);
// bool noErrors = ed.noErrorsInTheReport(cpv1);
// if (noErrors && fullPath) {
// std::cout << "DDCompareCPV did not find any errors and is finished." << std::endl;
// }
// else {
// ed.report(cpv1, std::cout);
// if (!noErrors) {
// return 1;
// }
// }
DDCompareCPV ddccpv(ddco);
bool graphmatch = ddccpv(cpv1, cpv2);
if (graphmatch) {
std::cout << "DDCompactView graphs match" << std::endl;
} else {
std::cout << "DDCompactView graphs do NOT match" << std::endl;
}
// Now set everything back to defaults
std::cout.flags( originalFlags );
return 0;
}
