void VisualStudioProvider::outputGlobalPropFile(std::ofstream &properties, int bits, const StringList &defines, const std::string &prefix, bool runBuildEvents) {
std::string warnings;
for (StringList::const_iterator i = _globalWarnings.begin(); i != _globalWarnings.end(); ++i)
warnings += *i + ';';
std::string definesList;
for (StringList::const_iterator i = defines.begin(); i != defines.end(); ++i) {
if (i != defines.begin())
definesList += ';';
definesList += *i;
}
// Add define to include revision header
if (runBuildEvents)
definesList += REVISION_DEFINE ";";
properties << "<?xml version=\"1.0\" encoding=\"Windows-1252\"?>\n"
"<VisualStudioPropertySheet\n"
"\tProjectType=\"Visual C++\"\n"
"\tVersion=\"8.00\"\n"
"\tName=\"" << PROJECT_DESCRIPTION << "_Global\"\n"
"\tOutputDirectory=\"$(ConfigurationName)" << bits << "\"\n"
"\tIntermediateDirectory=\"$(ConfigurationName)" << bits << "/$(ProjectName)\"\n"
"\t>\n"
"\t<Tool\n"
"\t\tName=\"VCCLCompilerTool\"\n"
"\t\tDisableLanguageExtensions=\"true\"\n"
"\t\tDisableSpecificWarnings=\"" << warnings << "\"\n"
"\t\tAdditionalIncludeDirectories=\"" << prefix << ";" << prefix << "\\engines;$(" << LIBS_DEFINE << ")\\include;$(TargetDir)\"\n"
"\t\tPreprocessorDefinitions=\"" << definesList << "\"\n"
"\t\tExceptionHandling=\"0\"\n";
#if NEEDS_RTTI
properties << "\t\tRuntimeTypeInfo=\"true\"\n";
#else
properties << "\t\tRuntimeTypeInfo=\"false\"\n";
#endif
properties << "\t\tRuntimeTypeInfo=\"false\"\n"
"\t\tWarningLevel=\"4\"\n"
"\t\tWarnAsError=\"false\"\n"
"\t\tCompileAs=\"0\"\n"
"\t\t/>\n"
"\t<Tool\n"
"\t\tName=\"VCLibrarianTool\"\n"
"\t\tIgnoreDefaultLibraryNames=\"\"\n"
"\t/>\n"
"\t<Tool\n"
"\t\tName=\"VCLinkerTool\"\n"
"\t\tIgnoreDefaultLibraryNames=\"\"\n"
"\t\tSubSystem=\"1\"\n"
"\t\tEntryPointSymbol=\"WinMainCRTStartup\"\n"
"\t\tAdditionalLibraryDirectories=\"$(" << LIBS_DEFINE << ")\\lib\\" << ((bits == 32) ? "x86" : "x64") << "\"\n"
"\t/>\n"
"\t<Tool\n"
"\t\tName=\"VCResourceCompilerTool\"\n"
"\t\tPreprocessorDefinitions=\"HAS_INCLUDE_SET\"\n"
"\t\tAdditionalIncludeDirectories=\"" << prefix << "\"\n"
"\t/>\n"
"</VisualStudioPropertySheet>\n";
properties.flush();
}
VOID trace_instrument(TRACE trace, VOID *v){
for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl)){
/* iterate over all basic blocks */
string codelet_string = "";
// this writes disassembly
char codelet_buffer[65536*2]; int cbs = 0;
INS head = BBL_InsHead(bbl);
INS tail = BBL_InsTail(bbl);
ADDRINT stage_entry = INS_Address( head );
ADDRINT target = 0;
if (INS_IsCall(tail)){
if( INS_IsDirectBranchOrCall(tail)){
target = INS_DirectBranchOrCallTargetAddress(tail);}}
INS cur ;
int branch_id = slp_count;
/* If compression is turned off (default), only output the addresses of
* the BBL once
*/
if (!KnobNoCompress){
/* Instrument the head instruction right before it is called, but also
* before we instrument the instructions in the basic block
*/
string msg_pre = "\n@@BBL(" + decstr( branch_id ) + ") STAGE " + Target2String(stage_entry)->c_str() + "\n" ;
INS_InsertCall(head, IPOINT_BEFORE, AFUNPTR(string_report),
IARG_PTR, new string(msg_pre),
IARG_END);
}
/* Walk the list of instructions inside the BBL. Disassemble each, and add
* it to the codelet string. Also, instrument each instruction at the
* point before it is called with the do_count function.
*/
for ( cur = head; INS_Valid( cur ); cur = INS_Next(cur ) ){
cbs += sprintf( codelet_buffer + cbs , "\n\t@%llx\t%s", INS_Address( cur ), INS_Disassemble( cur ).c_str() );
INS_InsertCall(cur, IPOINT_BEFORE, (AFUNPTR)do_count, IARG_ADDRINT, INS_Address( cur ), IARG_END);
}
/* Finish off the codelet assembly string with an out message and
* address ranges of the BBL
*/
cbs += sprintf( codelet_buffer + cbs , "\n\t}BBL.OUT [%d] %llx - %llx\n", branch_id, INS_Address( head ), INS_Address( tail ));
/* If compression is turned on, output the codelet every single time we
* hit the same block.
*/
if(KnobNoCompress){
INS_InsertCall(tail, IPOINT_BEFORE, AFUNPTR(string_report),
IARG_PTR, new string(codelet_buffer),
IARG_END);
slp_count ++;
}
else{
/* add the mapped BBL to output */
TraceFile.write(codelet_buffer, cbs);
/* Instrument the tail instruction by inserting just before it is called
*/
string msg_post = "+@@BBL(" + decstr( branch_id ) + ") ACHIEVE : GOTO " + Target2String(target)->c_str();
INS_InsertCall(tail, IPOINT_BEFORE, AFUNPTR(string_report),
IARG_PTR, new string(msg_post),
IARG_END);
slp_count ++;
}
}
}
VOID Fini(INT32 code, VOID *v)
{
TraceFile.close();
}
bool write(const uint8_t v) { m_fp.put(v); return true; }
AutoThread::~AutoThread()
{
output.close();
}
uint64_t tell() { return m_fp.tellp(); }
bool is_open() { return m_fp.is_open(); }
namespace Log {
// component-scope variables
const unsigned int log_master = 0;
std::string log_file;
std::ofstream lout;
bool initialized = false;
std::stringstream buffer;
// =========================================================================
// Set up
void setup () {
// ----------------------------------------------------------------------
// Initialize the Log component
// Name of log file
log_file = Parameters::get_optional<std::string>(
"Log.log_file", "log.txt");
log_file = Driver::output_dir + log_file;
// Open log file
#ifdef PARALLEL_MPI
if (Driver::proc_ID == log_master) {
lout.open(log_file.c_str());
}
#else // PARALLEL_MPI
lout.open(log_file.c_str());
#endif // PARALLEL_MPI
initialized = true;
// Write the log file header
lout << "Hydrodynamics Simulation" << std::endl << std::endl;
// If the buffer is not empty, push it to the file
lout << buffer.str();
buffer.clear();
buffer.str("");
}
// =========================================================================
// Clean up
void cleanup () {
// Final printing
write_single("\n" + std::string(79,'_') + "\nProgram Complete\n");
if (initialized) {
// If the log file is open, close it
#ifdef PARALLEL_MPI
if (Driver::proc_ID == log_master) {
#endif // PARALLEL_MPI
lout.close();
initialized = false;
#ifdef PARALLEL_MPI
}
#endif // PARALLEL_MPI
} else {
// If the log file was never opened, print the buffer to the screen
std::cout << buffer.str();
buffer.clear();
buffer.str("");
}
}
// =========================================================================
// Write to the log file
void write_all(std::string message) {
#ifdef PARALLEL_MPI
// Declare variables
int length, max_length;
char *send_buf, *recv_buf;
// MPI_Allreduce to determine length of longest message
length = message.length();
MPI_Allreduce(&length, &max_length, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
// Pad message to max_length
message.resize(max_length, '\0');
// Allocate a character array of max_length
send_buf = (char*) message.c_str();
recv_buf = new char[Driver::n_procs*max_length];
// MPI_Gather the messages into a read buffer
MPI_Gather(send_buf, max_length, MPI_CHAR,
recv_buf, max_length, MPI_CHAR, log_master, MPI_COMM_WORLD);
// If you are the master:
if (Driver::proc_ID == log_master) {
// Parse the read buffer into individual messages
for (int i = 0; i < Driver::n_procs; i++) {
for (int j = 0; j < max_length; j++) {
if (recv_buf[i*max_length+j] == '\0') {
break;
}
write_single(recv_buf[i*max_length+j]);
}
}
}
#else // PARALLEL_MPI
write_single(message);
#endif // PARALLEL_MPI
}
// =========================================================================
// Flush
void flush() {
lout.flush();
}
}
bool EyeRecord::saveToStream(std::ofstream& output) const
{
output.write((const char*) &cEYES, 4);
if (!saveSizeAndUnknownValues(output, getWriteSize())) return false;
//write EDID
output.write((const char*) &cEDID, 4);
//EDID's length
uint16_t subLength = editorID.length()+1;
output.write((const char*) &subLength, 2);
//write editor ID
output.write(editorID.c_str(), subLength);
//write FULL
if (!name.saveToStream(output, cFULL))
return false;
//write ICON
output.write((const char*) &cICON, 4);
//ICON's length
subLength = iconPath.length()+1;
output.write((const char*) &subLength, 2);
//write icon path
output.write(iconPath.c_str(), subLength);
//write DATA
output.write((const char*) &cDATA, 4);
//DATA's length
subLength = 1;
output.write((const char*) &subLength, 2);
//write DATA's content
output.write((const char*) &flags, 1);
return output.good();
}
bool Cylinder::saveParameters(std::ofstream& fout) const
{
fout << "# cylinder normal_x normal_y normal_z point_x point_y point_z radius" << std::endl;
fout << "cylinder " << _normal << " " << _point << " " << _radius << std::endl;
return fout.good();
}
void flush() {
lout.flush();
}
bool PathGridRecord::saveToStream(std::ofstream& output) const
{
output.write((const char*) &cPGRD, 4);
uint32_t Size;
Size = 4 /* DATA */ +4 /* 4 bytes for length */ + 12 /* size of data */
+4 /* NAME */ +4 /* 4 bytes for length */
+CellName.length()+1 /* length of cell name +1 byte for NUL termination */;
if (!Points.empty())
{
Size = Size + 4 /* PGRP */ +4 /* 4 bytes for length */
+16 * Points.size();
}
if (!Connections.empty())
{
Size = Size + 4 /* PGRC */ +4 /* 4 bytes for length */
+8 * Connections.size();
}
output.write((const char*) &Size, 4);
output.write((const char*) &HeaderOne, 4);
output.write((const char*) &HeaderFlags, 4);
/*Path Grid:
DATA = (path grid data, 12 bytes)
int32_t GridX
int32_t GridY
uint16_t Granularity (a power of two within [128;4096])
uint16_t NumQuads (number of points in PGRP)
NAME = name of cell the grid belongs to
PGRP = unknown data (path grid points?)
looks like an array of int32_t quads
struct PointData
{
int32_t X
int32_t Y
int32_t Z
int32_t Unknown
};
PGRC = unknown data (length: ?)
Possibly path grid connections?
Looks like an array of uint32_t pairs, where
first value is the index of the starting point
and second value is index of the end point.
*/
//write DATA
output.write((const char*) &cDATA, 4);
//DATA's length
uint32_t SubLength;
SubLength = 12; //length is always twelve bytes
output.write((const char*) &SubLength, 4);
//write path grid data
output.write((const char*) &GridX, 4);
output.write((const char*) &GridY, 4);
output.write((const char*) &Granularity, 2);
output.write((const char*) &NumQuads, 2);
//write NAME
output.write((const char*) &cNAME, 4);
//NAME's length
SubLength = CellName.length()+1;//length of string plus one for NUL-termination
output.write((const char*) &SubLength, 4);
//write cell name
output.write(CellName.c_str(), SubLength);
if (!Points.empty())
{
//write PGRP
output.write((const char*) &cPGRP, 4);
//PGRP's length
SubLength = Points.size()*16;//length is 16 bytes per point
output.write((const char*) &SubLength, 4);
//write points
unsigned int i;
for (i=0; i<Points.size(); ++i)
{
//write next point
output.write((const char*) &(Points[i].X), 4);
output.write((const char*) &(Points[i].Y), 4);
output.write((const char*) &(Points[i].Z), 4);
output.write((const char*) &(Points[i].Unknown), 4);
}//for
}//Points
if (!Connections.empty())
{
//write PGRC
output.write((const char*) &cPGRC, 4);
//PGRC's length
SubLength = Connections.size()*8;//length is 8 bytes per connection
output.write((const char*) &SubLength, 4);
//write connections
unsigned int i;
for (i=0; i<Connections.size(); ++i)
{
//write next point
output.write((const char*) &(Connections[i].Start), 4);
output.write((const char*) &(Connections[i].End), 4);
}//for
}//connections
return output.good();
}
virtual void sample() {
DVLOG(5) << "sampling " << name;
if (value_ != nil_value) log.write((char*)&value_, sizeof(&value_));
value_ = nil_value;
}
int main(int argcc, char* argvv[])
{
Magick::InitializeMagick(NULL);
// welcome to the main :)
std::stringstream ss_welcome;
ss_welcome << "*** " << NAME <<" v. " << SDVERSION << " - Analysis of 2D/3D multicolor SD-dSTORM data ***" ;
std::cout << "\n" << ss_welcome.str() << std::endl;
int dir_match_count = 0;
int file_match_count = 0;
std::string default_config_filename = NAME".conf"; // if u haven't specified it in the command-line
std::string logfilename = get_date().append("_" NAME ".log");
//std::string strDimensions;
unsigned long file_count = 0;
unsigned long dir_count = 0;
unsigned long err_count = 0;
std::stringstream ssusage_string;
ssusage_string << "\nUsage: " << argvv[0] <<
" PATH [OPTIONS] \nruns "<< NAME << " in working directory \n\n" <<
"optional arguments:\n" <<
"\t-d \t\t : if specified, 2D image output of a 3D data set\n" <<
"\t-o \t\t : one-color flag, overrides filter information\n" <<
"\t-c FILENAME \t : specify an alternative configuration file\n" <<
"\t-s STAGE_VALUE \t : skip stage, value has to be 1, 2 or 3.\n\t\t\t 1: skip PairFinder" <<
"\n\t\t\t 2: skip Filter" <<
"\n\t\t\t 3: skip Reconstructor\n" <<
"\t-e STAGE_VALUE \t : end after stage, value has to be 1 or 2.\n\t\t\t 1: end after PairFinder" <<
"\n\t\t\t 2: end after Filter\n" <<
"\t-h \t\t : print this usage information\n"
<< std::endl;
int nonopt_count = 0; // counter for optional argumnets
bool force_dim = false; // -d
int hflag = 0; // -h
bool one_color = false;
char *opt_conf_file = NULL;
int skip_stage = 0; // value of -s
int end_stage = 0; // value of -e
int index;
int c;
opterr = 0;
while ((c = getopt (argcc, argvv, "dc:s:e:oh")) != -1)
{
switch (c)
{
case 'd':
force_dim = true; // force 2d analysis of 3d data set (why should one do this :)?
break;
case 'c':
opt_conf_file = optarg; // c-style string to our optional config file
break;
case 's':
skip_stage = atoi(optarg);
if (skip_stage != 1 && skip_stage != 2 && skip_stage != 3)
{
std::cout << "\nERROR: skip stage: value has to be 1, 2 or 3\n" << std::endl;
return 1;
}
break;
case 'e':
end_stage = atoi(optarg);
if (end_stage != 1 && end_stage != 2)
{
std::cout << "\nERROR: end after stage: value has to be 1 or 2\n" << std::endl;
return 1;
}
break;
case 'o':
one_color = true; // one-color flag, overrides filter information
break;
case 'h':
hflag = 1;
std::cout << ssusage_string.str() ;
return 1;
break;
case '?':
if (optopt == 'c' || optopt == 's')
{
std::cout << "\nERROR: Option '-" << (char) optopt << "' requires an argument\nrun " << argvv[0] << " -h for help\n";
}
else if (isprint (optopt))
{
std::cout << "\nERROR: Unknown option '-" << (char) optopt << "'\nrun " << argvv[0] << " -h for help\n";
}
else // who the f*** would enter "umlaute" und/oder ß as an argument???
{
std::cout << "\nERROR: Unknown optional character '-" << (wchar_t)optopt <<
"', Non-ASCII characters are not valid arguments!\nrun " << argvv[0] << " -h for help\n";
}
return 1;
default:
abort ();
}
}
if (optind == argcc && hflag == 0) // jeah, genius give me an working dir or an help flag!
{
std::cout << "\nERROR: no path to working dir specified!\nrun " << argvv[0] << " -h for help\n";
return 1;
}
for (index = optind; index < argcc; index++)
{
++nonopt_count;
}
if (nonopt_count > 1) // one working dir is enough!
{
std::cout << "\nERROR: only one path to working dir is allowed!\nrun " << argvv[0] << " -h for help\n";
return 1;
}
std::vector<std::string> dir_list;
std::vector<std::string> file_list;
boost::property_tree::ptree ptree_config_file;
fs::path full_path( fs::initial_path<fs::path>() );
full_path = fs::system_complete( fs::path( argvv[optind] ) ); // full path is the specified working dir
// this is seriously strange work-around to run octave main
// but it works.
// it would cause a segmentation fault when octave_main()
// would be run with not the same nr. of args that were passed to the
//sdmixer main.. ???
string_vector om(argcc); //
for (int a = 0; a<argcc; ++a)
{
om(a) = "--silent";
//om(a) = "-x";
}
octave_main(argcc, om.c_str_vec(), 1); // now its ok
// if you have a better solution write to: [email protected]
if ( !fs::exists( full_path ) )
{
std::cout << "\nERROR: working directory not found: " << full_path.string() << std::endl << std::endl;
return 1;
}
fs::path config_file_full_path = operator/(full_path, default_config_filename); // add name of default config file to working dir
// really nice construct this "operator/" it adds
// the right directory_seperator for unix "/"
// let's see if it works with windows...
if (opt_conf_file != NULL) // user specified an other location for the config file
{
config_file_full_path = opt_conf_file; // redefinition of the path above
if (!std::ifstream(config_file_full_path.string().c_str()))
{
std::cout << "\nERROR: failed opening specified configuration file " << config_file_full_path.string() << std::endl;
return 1;
}
}
else
{
if (!std::ifstream(config_file_full_path.string().c_str()))
{
std::cout << "\nERROR: no configuration file found in the working directory." << std::endl;
return 1;
}
}
fs::path log_file_full_path = operator/(full_path,logfilename);
// fs::path log_file_full_path2 = operator/(full_path,"log.out");
logFile.open(log_file_full_path.string().c_str());
//LogFile::GetInstance()->OpenLogFile(log_file_full_path2.string().c_str());
/*
LogFile &lg = *LogFile::GetInstance();
lg.OpenLogFile(log_file_full_path2.string().c_str());
lg << "Test\n";
*/
if (!std::ifstream(log_file_full_path.string().c_str()))
{
std::cout << "\nERROR: unable to write logfile in working dir." << std::endl;
return 1;
}
//logFile << "\n*** " << NAME <<" v. " << SDVERSION << " - Analysis of 2D/3D multicolor SD-dSTORM data ***\n" << std::endl;
logFile << ss_welcome.str() << "\n" << std::endl;
std::string search_pattern_dir;
std::string search_pattern_file;
try // try to read the config file
{
boost::property_tree::ini_parser::read_ini(config_file_full_path.string(), ptree_config_file);
}
catch( const std::exception & ex )
{
std::cout << "\nERROR: syntax error in config file: " << config_file_full_path.string() << std::endl << ex.what() << std::endl;
return 1;
}
try // try to load some config-file entries
{
search_pattern_dir = ptree_config_file.get<std::string>("General.search_pattern_dir");
search_pattern_file = ptree_config_file.get<std::string>("General.search_pattern_file");
PairFinderFileStamp = ptree_config_file.get<std::string>("PairFinder.FileStamp");
FilterFileStamp = ptree_config_file.get<std::string>("Filter.FileStamp");
//crap!
std::string str_grouping = ptree_config_file.get<std::string>("grouping.grouping_on");
std::string str_groupingFileStamp = ptree_config_file.get<std::string>("grouping.OutputFileStamp");
//CHANGE ME!!
int grouping_on = atoi(str_grouping.c_str());
PairFinderFileStampGroupingFailed = PairFinderFileStamp; //just in case there are no groups..
if(grouping_on != 0)
PairFinderFileStamp = PairFinderFileStamp+str_groupingFileStamp;
}
catch( const std::exception & ex )
{
std::cout << "\nERROR: syntax error in config file: " << config_file_full_path.string() << std::endl << ex.what() << std::endl;
return 1;
}
boost::regex pattern_dir(search_pattern_dir.c_str(), boost::regex_constants::icase);
boost::regex pattern_file(search_pattern_file.c_str(), boost::regex_constants::icase);
if ( fs::is_directory( full_path ) ) // the working dir should be an directory
{
try
{
fs::directory_iterator end_iter;
//std::cout << "\nWorking directory: " << full_path.string() << "\n" << std::endl;
for ( fs::directory_iterator dir_itr( full_path ); dir_itr != end_iter; ++dir_itr )
{
try
{
if ( fs::is_directory( dir_itr->status() ) ) // found a directory
{
++dir_count;
std::stringstream ssfile;
ssfile << dir_itr->path().filename();
if (boost::regex_match(ssfile.str(), pattern_dir)) //dir matches the search pattern from config file
{ //
std::string match_dir = ssfile.str(); //
fs::path full_path_matched_dir = operator/(full_path.string(), dir_itr->path().filename());
dir_list.push_back(full_path_matched_dir.string()); // add to vector which contains all our matched dirs
++dir_match_count;
}
}
else if ( fs::is_regular_file( dir_itr->status() ) ) // found a subdir in the working dir
{
++file_count;
std::stringstream ssfile;
ssfile << dir_itr->path().filename();
if (boost::regex_match(ssfile.str(), pattern_file)) // pattern matching?
{
std::string match_file = ssfile.str();
fs::path full_path_matched_file = operator/(full_path.string(), dir_itr->path().filename());
file_list.push_back(full_path_matched_file.string()); // yes, add to vector containing all the files
++file_match_count;
}
}
}
catch ( const std::exception & ex )
{
++err_count;
std::cout << dir_itr->path().filename() << " " << ex.what() << std::endl;
return 1;
}
}
}
catch ( const std::exception & ex )
{
std::cout << "ERROR: failed opening directory " << full_path.string() << std::endl << ex.what() << std::endl;
return 1;
}
}
else
{
std::cout << "\nERROR: " << full_path.string() << " is not a directory" << std::endl << std::endl;
return 1;
}
if ( file_match_count == 0 && dir_match_count != 0)
{
std::sort(dir_list.begin(), dir_list.end());
//std::cout << "\nstarting analysis of " << dir_match_count << " subdirectorie(s). lean back, this may take a while...\n\n";
AnalyseDirs(ptree_config_file, config_file_full_path, force_dim, one_color, dir_list, skip_stage, full_path.string(), end_stage);
}
if ( file_match_count != 0 && dir_match_count == 0)
{
int nr_of_dir = 0;
//std::cout << "\nstarting analysis of " << file_match_count << " file(s) in the working directory.\n";
std::sort(file_list.begin(), file_list.end());
AnalyseFiles(ptree_config_file, config_file_full_path, force_dim, one_color, file_list, skip_stage, full_path.string(), end_stage, dir_list, nr_of_dir);
}
if ( file_match_count != 0 && dir_match_count != 0)
{
std::cout << "\nERROR: found " << file_match_count << " file(s) and "
<< dir_match_count << " directorie(s) that matched the search pattern\n" <<
"please make sure that your working directory contains either subdirectories\nwhich content has to be processed " <<
"OR files that have to be processed. Not both!\n" <<
"don't know what you want me to do. terminating\n\n";
return 1;
}
if ( file_match_count == 0 && dir_match_count == 0)
{
std::cout << "\nfound no files or directories that match the regex search pattern.\nNothing to do, terminating..\n\n";
return 0;
}
}
void createOutputFile (std::ofstream & outputFile, FILE * ptr_fp, bool isRestart, double delT, double delV,
double tMin, double tMax, double vMin, double vMax, int Nvsteps, int Ntsteps,
int downSampleT, int downSampleV, char * rChoice, char * regionChoice,
char * distChoice, char * scattType, char * gradientOption, double vthe,
double memi, double B, double wpe, double wce, double wci, double beta_e,
double vA, double c1, double nu, double omega, double delB, double deln,
double delR, double kpar, int Lx, int l0) {
if (isRestart == 1) {
outputFile.open("outputFile.txt", std::ios::out | std::ios::app);
std::cout << "Restart -> appending already existing outfile" << std::endl;
} else {
// Opening output file
outputFile.open("outputFile.txt");
// Opening saving file
/*if((ptr_fp = fopen("cppTestOutput.bin", "ab")) == NULL)
{
printf("Unable to open file!\n");
exit(1);
}else printf("Opened file successfully for writing.\n");*/
// Adding important information to the output file
outputFile << "Simulation Variables:" << std::endl;
outputFile << "delT = " << delT << std::endl;
outputFile << "delV = " << delV << std::endl;
outputFile << "tMin = " << tMin << std::endl;
outputFile << "tMax = " << tMax << std::endl;
outputFile << "vMin = " << vMin << std::endl;
outputFile << "vMax = " << vMax << std::endl;
outputFile << "Nvsteps = " << Nvsteps << std::endl;
outputFile << "Ntsteps = " << Ntsteps << std::endl;
outputFile << "downSampleT = " << downSampleT << std::endl;
outputFile << "downSampleV = " << downSampleV << std::endl << std::endl;
outputFile << "Physical Variables:" << std::endl;
outputFile << "rChoice = " << rChoice << std::endl;
outputFile << "regionChoice = " << regionChoice << std::endl;
outputFile << "distChoice = " << distChoice << std::endl;
outputFile << "scattType = " << scattType << std::endl;
outputFile << "gradientOption = " << gradientOption << std::endl << std::endl;
outputFile << "Physical Parameters:" << std::endl;
outputFile << "vthe = " << vthe << std::endl;
outputFile << "memi = " << memi << std::endl;
outputFile << "B = " << B << std::endl;
outputFile << "wpe = " << wpe << std::endl;
outputFile << "wce = " << wce << std::endl;
outputFile << "wci = " << wci << std::endl;
outputFile << "beta_e = " << beta_e << std::endl;
outputFile << "vA = " << vA << std::endl;
outputFile << "c1 = " << c1 << std::endl;
outputFile << "nu = " << nu << std::endl;
outputFile << "omega = " << omega << std::endl;
outputFile << "delB = " << delB << std::endl;
outputFile << "deln = " << deln << std::endl;
outputFile << "delR = " << delR << std::endl;
outputFile << "kpar = " << kpar << std::endl;
outputFile << "Lx = " << Lx << std::endl;
outputFile << "l0 = " << l0 << std::endl << std::endl;
outputFile << "Simulation Output:" << std::endl;
}
}
// where everything begins...
int main(int argc, char** argv)
{
const unsigned ONECHAR_ARG = 3, TWOCHAR_ARG = 4;
// check that syntax is ok
if (argc != 4)
{
std::cerr << "syntax: regress <options file> <xml file> <output file>" << std::endl;
return -1;
}
// read in the options file
std::ifstream options_in(argv[1]);
if (options_in.fail())
{
std::cerr << "regress: error opening options file " << argv[1] << std::endl;
return -1;
}
// get the options
std::vector<std::string> options;
std::string str;
while (true)
{
options_in >> str;
if (options_in.eof())
break;
options.push_back(str);
}
options_in.close();
// get all options
for (unsigned i=0; i< options.size(); i++)
{
// get the option
const std::string& option = options[i];
// process options
if (option.find("-oi") != std::string::npos)
OUTPUT_ITER_NUM = true;
else if (option.find("-or") != std::string::npos)
OUTPUT_SIM_RATE = true;
else if (option.find("-s=") != std::string::npos)
{
STEP_SIZE = std::atof(option.substr(ONECHAR_ARG).c_str());
assert(STEP_SIZE >= 0.0 && STEP_SIZE < 1);
}
else if (option.find("-mi=") != std::string::npos)
{
MAX_ITER = std::atoi(option.substr(TWOCHAR_ARG).c_str());
assert(MAX_ITER > 0);
}
else if (option.find("-mt=") != std::string::npos)
{
MAX_TIME = std::atof(option.substr(TWOCHAR_ARG).c_str());
assert(MAX_TIME > 0);
}
else if (option.find("-p=") != std::string::npos)
read_plugin(option.substr(ONECHAR_ARG));
}
// setup the simulation
READ_MAP = XMLReader::read(std::string(argv[argc-2]));
// get the (only) simulation object
boost::shared_ptr<Simulator> s;
for (std::map<std::string, BasePtr>::const_iterator i = READ_MAP.begin(); i != READ_MAP.end(); i++)
{
s = boost::dynamic_pointer_cast<Simulator>(i->second);
if (s)
break;
}
// make sure that a simulator was found
if (!s)
{
std::cerr << "regress: no simulator found in " << argv[argc-2] << std::endl;
return -1;
}
// setup the output file
outfile.open(argv[argc-1]);
// call the initializers, if any
if (!INIT.empty())
{
BOOST_FOREACH(init_t i, INIT)
(*i)(NULL, READ_MAP, STEP_SIZE);
}
// begin timing
start_time = clock();
// begin rendering
while (step((void*) &s))
{
}
// close the loaded library
for(size_t i = 0; i < handles.size(); ++i) {
dlclose(handles[i]);
}
// write the number of clock ticks elapsed
clock_t end_time = clock();
double elapsed = (end_time - start_time) / (double) CLOCKS_PER_SEC;
outfile << elapsed << std::endl;
// close the output file
outfile.close();
}
bool BamProcessor::init (const ContalignParams& p)
{
read_cnt_ = proc_cnt_ = toolongs_ = unaligned_cnt_ = fail_cnt_ = nomd_cnt_ = realigned_cnt_ = modified_cnt_ = pos_adjusted_cnt_ = 0;
log_diff_ = log_matr_ = log_base_ = false;
p_ = &p;
if (!*p.inbam ())
ers << "Input file name not specified" << Throw;
limit_ = p.limit ();
skip_ = p.skip ();
infile_.OpenForRead (p.inbam ());
if (!infile_.IsOpen ())
ers << p.inbam () << ThrowEx (FileNotFoundRerror);
bool index_ok = false;
if (*p.bamidx ())
{
index_ok = infile_.ReadBamIndex (p.bamidx ());
if (!index_ok)
warn << "Unable to open specified BAM index: " << p.bamidx () << ". Default index will be attempted" << std::endl;
}
if (!index_ok)
{
try
{
index_ok = infile_.ReadBamIndex ();
}
catch (std::exception& e)
{
// for some reason not converted into return status by libStatGen
}
if (!index_ok)
warn << "Unable to open default BAM index for " << p.inbam () << std::endl;
}
if (*p.refname () || p.refno () != -1)
{
if (!index_ok)
ers << "Reference section specified, but the BAM index could not be open." << Throw;
if (*p.refname ())
{
if (p.endpos () != 0)
{
infile_.SetReadSection (p.refname (), p.begpos (), p.endpos ());
info << "Read section set : " << p.refname () << ": " << p.begpos () << "-" << p.endpos () << std::endl;
}
else
{
infile_.SetReadSection (p.refname ());
info << "Read section set : " << p.refname () << std::endl;
}
}
else
{
if (p.endpos () != 0)
{
info << "Read section set : ref# " << p.refno () << ": " << p.begpos () << "-" << p.endpos () << std::endl;
infile_.SetReadSection (p.refno (), p.begpos (), p.endpos ());
}
else
{
info << "Read section set : ref# " << p.refno () << std::endl;
infile_.SetReadSection (p.refno ());
}
}
}
if (*p.outbam ())
{
if (!p.overwrite () && file_exists (p.outbam ()))
ers << "Output file " << p.outbam () << " exists. Use --ov key to allow overwriting" << Throw;
outfile_.OpenForWrite (p.outbam ());
if (!outfile_.IsOpen ())
ers << "Unable to open output file " << p.outbam () << std::endl;
}
if (*p.logfname ())
{
if (!p.overwrite () && file_exists (p.logfname ()))
ers << "Log file " << p.logfname () << " exists. Use --ov key to allow overwriting" << Throw;
logfile_.open (p.logfname (), std::fstream::out);
if (!logfile_.is_open ())
ers << "Unable to open log file " << p.logfname () << std::endl;
time_t t = time (NULL);
logfile_ << "Context-aware realigner log\nStarted at " << asctime (localtime (&t)) << "\nParameters:\n";
logfile_ << *(p.parameters_);
logfile_ << std::endl;
log_base_ = p.logging ("base");
log_diff_ = p.logging ("diff");
log_matr_ = p.logging ("matr");
}
band_width_ = p.bwid ();
switch (p.algo ())
{
case ContalignParams::TEMPL:
{
matrix_.configure (genstr::nucleotides.symbols (), genstr::nucleotides.size (), genstr::NegUnitaryMatrix <int, 4>().values ());
gap_cost_.configure (p.gip (), p.gep ());
taligner_.configure (&matrix_, &gap_cost_, &gap_cost_, &genstr::nn2num, &genstr::nn2num);
}
break;
case ContalignParams::PLAIN:
{
batches_.reset (max_batch_no_);
aligner_.init (MAX_SEQ_LEN, MAX_SEQ_LEN*MAX_BAND_WIDTH, p.gip (), p.gep (), p.mat (), -p.mis ());
if (log_matr_)
aligner_.set_log (logfile_);
if (p.debug () > 5)
aligner_.set_trace (true);
}
break;
case ContalignParams::POLY:
{
batches_.reset (max_batch_no_);
contalign_.init (MAX_SEQ_LEN, MAX_RSEQ_LEN, MAX_SEQ_LEN*MAX_BAND_WIDTH, p.gip (), p.gep (), p.mat (), -p.mis ());
if (log_matr_)
contalign_.set_log (logfile_);
if (p.debug () > 5)
contalign_.set_trace (true);
}
break;
default:
{
ers << "Alignment algorithm " << p.algostr () << " not yet supported" << Throw;
}
}
timer_.reset (DEFAULT_REPORT_IVAL, 1);
return true;
}
static void closeFileStream(std::ofstream& fileStream) {
assert_true(fileStream.good());
fileStream.close();
}
uint64_t seek(const uint64_t offs) { m_fp.seekp(offs,std::ios::beg); return m_fp.tellp(); }
/** Open file stream to write in */
static void openTextFileStream(std::ofstream& fileStream,
const std::string& fileName) {
fileStream.open(fileName, std::ios::out);
assert_true(fileStream.is_open());
fileStream.clear();
}
bool close() { m_fp.close(); return true; }
VOID Fini(int, VOID * v)
{
out << "# eof" << endl;
out.close();
}
static void flush(std::ofstream& out)
{
out.write(_outBuffer, _outBufferSize);
_outBufferSize = 0;
}
void ParticleEmitterComponent::DoSerialization(std::ofstream &saveStream) const
{
saveStream.write((char*)&particleEmitInterval_s, sizeof(particleEmitInterval_s));
saveStream.write((char*)&lastTimeOfEmission_s, sizeof(lastTimeOfEmission_s));
saveStream.write((char*)&particlesPerEmission, sizeof(particlesPerEmission));
}
static int process_arg(std::string &basename,
std::ofstream &fout,
const int argc,
char* argv[],
float &min,
float &max,
int &num,
int &sfid,
int &efid)
{
for (int i = 1; i < argc; ++i){
std::string arg = argv[i];
if ((arg == "-h") || (arg == "--help")){
show_usage(argv[0]);
return 0;
}
else if ((arg == "-i") || (arg == "--input")){
if (i + 1 < argc){
//fin.push_back(new std::ifstream(argv[i + 1], std::ios::in));
basename = argv[i + 1];
i++;
}
else {
std::cerr << "--input option requires one argument." << std::endl;
return 1;
}
}
else if ((arg == "-l") || (arg == "--lower")){
if (i + 1 < argc){
min = strtof(argv[i + 1], NULL);
i++;
}
else {
std::cerr << "--input option requires one argument." << std::endl;
return 1;
}
}
else if ((arg == "-u") || (arg == "--upper")){
if (i + 1 < argc){
max = strtof(argv[i + 1], NULL);
i++;
}
else {
std::cerr << "--input option requires one argument." << std::endl;
return 1;
}
}
else if ((arg == "-N") || (arg == "--boxes")){
if (i + 1 < argc){
num = int(strtof(argv[i + 1], NULL));
i++;
}
else {
std::cerr << "--input option requires one argument." << std::endl;
return 1;
}
}
else if ((arg == "-s") || (arg == "--start")){
if (i + 1 < argc){
sfid = int(strtod(argv[i + 1], NULL));
i++;
}
else {
std::cerr << "--input option requires one argument." << std::endl;
return 1;
}
}
else if ((arg == "-e") || (arg == "--end")){
if (i + 1 < argc){
efid = int(strtod(argv[i + 1], NULL));
i++;
}
else {
std::cerr << "--input option requires one argument." << std::endl;
return 1;
}
}
else if ((arg == "-o") || (arg == "--output")){
if (i + 1 < argc){
fout.open(argv[i + 1]);
i++;
}
else{
std::cerr << "--output option requires one argument." << std::endl;
return 1;
}
}
else{
fout.open("SvT.csv");
return 2;
}
}
}
bool LoadScreenRecord::saveToStream(std::ofstream& output) const
{
output.write((const char*) &cLSCR, 4);
if (!saveSizeAndUnknownValues(output, getWriteSize())) return false;
//write EDID
output.write((const char*) &cEDID, 4);
//EDID's length
uint16_t subLength = editorID.length()+1;
output.write((const char*) &subLength, 2);
//write editor ID
output.write(editorID.c_str(), subLength);
//write DESC
if (!text.saveToStream(output, cDESC))
return false;
std::vector<CTDA_CIS2_compound>::size_type i;
for (i=0; i<unknownCTDA_CIS2s.size(); ++i)
{
//write CTDA and CIS2
if (!unknownCTDA_CIS2s[i].saveToStream(output))
{
std::cout << "Error while writing CTDA and CIS2 of LSCR!\n";
return false;
}
}//for
//write NNAM
output.write((const char*) &cNNAM, 4);
//NNAM's length
subLength = 4; //fixed size
output.write((const char*) &subLength, 2);
//write NNAM
output.write((const char*) &unknownNNAM, 4);
//write SNAM
output.write((const char*) &cSNAM, 4);
//SNAM's length
subLength = 4; //fixed size
output.write((const char*) &subLength, 2);
//write SNAM
output.write((const char*) &unknownSNAM, 4);
//write RNAM
output.write((const char*) &cRNAM, 4);
//RNAM's length
subLength = 6;
output.write((const char*) &subLength, 2);
//write RNAM's stuff
output.write((const char*) unknownRNAM, 6);
//write ONAM
output.write((const char*) &cONAM, 4);
//ONAM's length
subLength = 4; //fixed size
output.write((const char*) &subLength, 2);
//write ONAM
output.write((const char*) &unknownONAM, 4);
//write XNAM
output.write((const char*) &cXNAM, 4);
//XNAM's length
subLength = 12;
output.write((const char*) &subLength, 2);
//write XNAM's stuff
output.write((const char*) unknownXNAM, 12);
if (!unknownMOD2.empty())
{
//write MOD2
output.write((const char*) &cMOD2, 4);
//MOD2's length
subLength = unknownMOD2.length()+1;
output.write((const char*) &subLength, 2);
//write model path
output.write(unknownMOD2.c_str(), subLength);
}
return output.good();
}
VOID string_report(const string *s){
TraceFile.write(s->c_str(), s->size());
}
void rsimpl::log_to_file(rs_log_severity min_severity, const char * file_path)
{
minimum_file_severity = min_severity;
log_file.open(file_path, std::ostream::out | std::ostream::app);
rsimpl::minimum_log_severity = std::min(minimum_console_severity, minimum_file_severity);
}
void OpenAndCleanFiles(){
if (isDefaultFolder)
{
Log.open("..//OutPut//Log.txt", ios::trunc | ios::app);
if (Log.is_open()) printf("Log File Not Open\n");
}
else
{
Log.open((OutPutFolder+"Log.txt").c_str(), ios::trunc | ios::app);
}
FILE * LogFile;
errno_t err;
if (isDefaultFolder)
{
err = fopen_s(&LogFile, "..//OutPut//Log.txt", "w");
}
else
{
err = fopen_s(&LogFile, (OutPutFolder+"Log.txt").c_str(), "w");
}
fclose(LogFile);
ofstream OutFile;
if (isDefaultFolder)
{
OutFile.open("..//OutPut//Summary.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//Paras.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//PrintInputRequest.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//AirLineDelayAndFairness.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//ResultRequest.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//AllocateTime.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//AirLineByRuleSummary.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//AllMovementDelay.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//GFSummary.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//NewSummary.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//OtherSummary.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//AllAirLineSummary.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//GFMovementDelay.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//NewMovementDelay.txt", ios::trunc);
OutFile.close();
OutFile.open("..//OutPut//OtherMovementDelay.txt", ios::trunc);
OutFile.close();
CplexLog.open("..//OutPut//CplexLog.txt", ios::trunc);
}
else
{
OutFile.open((OutPutFolder+"Summary.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder+"Paras.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder+"PrintInputRequest.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder+"AirLineDelayAndFairness.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder+"ResultRequest.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder+"AllocateTime.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder+"AirLineByRuleSummary.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder+"AllMovementDelay.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder + "GFSummary.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder + "NewSummary.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder + "OtherSummary.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder + "AllAirLineSummary.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder + "GFMovementDelay.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder + "NewMovementDelay.txt").c_str(), ios::trunc);
OutFile.close();
OutFile.open((OutPutFolder + "OtherMovementDelay.txt").c_str(), ios::trunc);
OutFile.close();
CplexLog.open((OutPutFolder + "CplexLog.txt").c_str(), ios::trunc);
}
}
void writePickle(){
int data_length = 0;
current_node = data_stream;
// find length of linked list
while (current_node->next != NULL){
data_length++;
current_node = current_node->next;
}
// create arrays to hold data
float * zRotArray;
zRotArray = new float[data_length];
float * xRotArray;
xRotArray = new float[data_length];
float * facingAngle;
facingAngle = new float[data_length];
// fill arrays, first node holds no data
current_node = data_stream->next;
data_stream_node * temp_node;
for (int i = 0; i < data_length - 1; i++){
zRotArray[i] = current_node->zRotAngle;
xRotArray[i] = current_node->xRotAngle;
facingAngle[i] = current_node->facingAngle;
temp_node = current_node;
current_node = temp_node->next;
delete temp_node;
}
current_node = data_stream;
// construct file name from time
time_t rawtime;
struct tm timeinfo;
char buffer[80];
time(&rawtime);
localtime_s(&timeinfo, &rawtime);
strftime(buffer, 80, "Kinect %Y_%m_%d %H-%M-%S", &timeinfo);
// create txt file
if (pickled_data == FALSE){
std::string file_name = std::string(buffer) + ".txt";
output_file.open(file_name);
output_file << std::flush;
output_file << "frames," << std::endl;
output_file << data_length - 1 << "," << std::endl;
output_file << "zRotAngle," << std::endl;
for (int i = 0; i < data_length - 1; i++){
output_file << zRotArray[i] << ",";
}
output_file << std::endl;
output_file << "xRotAngle," << std::endl;
for (int i = 0; i < data_length - 1; i++){
output_file << xRotArray[i] << ",";
}
output_file << std::endl;
output_file << "facingAngle," << std::endl;
for (int i = 0; i < data_length - 1; i++){
if (i < data_length - 2){
output_file << facingAngle[i] << ",";
}
else {
output_file << facingAngle[i] << std::endl;
}
}
output_file.close();
}
// create python pickle file
else { // pickled_data == TRUE
std::string file_name = std::string(buffer) + ".p";
output_file.open(file_name, std::ofstream::binary);
output_file << std::flush;
output_file << "(dp0" << "\n";
output_file << "S'frames'" << "\n";
output_file << "p1" << "\n";
output_file << "I" << data_length - 1 << "\n";
output_file << "sS'zRotAngle'" << "\n";
output_file << "p2" << "\n";
output_file << "(lp3" << "\n";
output_file << "F" << zRotArray[0] << "\n";
for (int i = 1; i < data_length - 1; i++){
output_file << "aF" << zRotArray[i] << "\n";
}
output_file << "asS'xRotAngle'" << "\n";
output_file << "p4" << "\n";
output_file << "(lp5" << "\n";
output_file << "F" << xRotArray[0] << "\n";
for (int i = 1; i < data_length - 1; i++){
output_file << "aF" << xRotArray[i] << "\n";
}
output_file << "asS'facingAngle'" << "\n";
output_file << "p6" << "\n";
output_file << "(lp7" << "\n";
output_file << "F" << facingAngle[0] << "\n";
for (int i = 1; i < data_length - 1; i++){
output_file << "aF" << facingAngle[i] << "\n";
}
output_file << "as.";
output_file.close();
}
}