void FilesGrouper::mergeSortedFiles(string fs1, string fs2, string output_file) {
ofstream merged_file(output_file);
string s1, s2;
ifstream ifs1(fs1);
ifstream ifs2(fs2);
getline(ifs1, s1);
getline(ifs2, s2);
while (ifs1.good() && ifs2.good()) {
if (s1 < s2) {
merged_file << s1;
getline(ifs1, s1);
} else {
merged_file << s2;
getline(ifs2, s2);
}
merged_file << "\n";
}
// finish off the remaining of each file and appending the previously read file name
if (ifs1.good()) {
merged_file << s1 << "\n";
while (getline(ifs1, s1))
merged_file << s1 << "\n";
} else {
merged_file << s2 << "\n";
while (getline(ifs2, s2))
merged_file << s2 << "\n";
}
merged_file.close();
}
// A helper function which compares a content of two files
bool compareFiles( const std::string & fileName1,
const std::string & fileName2 )
{
ifstream ifs1( fileName1.c_str() ), ifs2( fileName2.c_str() );
return NcbiStreamCompare(ifs1, ifs2);
}
int main(int argc, char** argv)
{
if (argc < 3)
{
std::cout << "Usage: combustion-vineyard FRAME1 FRAME2" << std::endl;
exit(0);
}
int size0, nc0;
int size1, nc1;
std::cout << "Reading: " << argv[1] << std::endl;
std::ifstream ifs0(argv[1], std::ios::binary);
std::cout << "Reading: " << argv[2] << std::endl;
std::ifstream ifs1(argv[2], std::ios::binary);
if (!ifs0 || !ifs1)
{
std::cout << "Could not open the frames" << std::endl;
exit(0);
}
read(ifs0, size0); read(ifs0, nc0);
read(ifs1, size1); read(ifs1, nc1);
assert(size0 == size1); assert(nc0 == nc1);
assert(size0 == xsize*ysize);
Grid2D g0(xsize, ysize), g1(xsize, ysize);
for (int y = 0; y < ysize; ++y)
for (int x = 0; x < xsize; ++x)
for (int d = 0; d < nc0; ++d)
{
float val0, val1;
read(ifs0, val0);
read(ifs1, val1);
if (d == var)
{
g0(x,y) = val0;
g1(x,y) = val1;
}
}
std::cout << "Grids read" << std::endl;
// Generate filtration and compute pairing
Grid2DVineyard v(&g0);
std::cout << "Filtration generated, size: " << v.filtration()->size() << std::endl;
v.compute_pairing();
std::cout << "Pairing computed" << std::endl;
// Compute vineyard
v.compute_vineyard(&g1, true);
std::cout << "Vineyard computed" << std::endl;
v.vineyard()->save_edges("combustion");
}
void read_file(std::string input1,std::string input2,std::string input3){
std::ifstream ifs1(input1.c_str());
std::ifstream ifs2(input2.c_str());
std::ifstream ifs3(input3.c_str());
float label1;
ifs1 >> input1;
ifs1 >> label1;
ifs1 >> label1;
ifs2 >> input2;
ifs2 >> label1;
ifs2 >> label1;
ifs3 >> input3;
ifs3 >> label1;
ifs3 >> label1;
int num=0;
int pos[3]={0};
int neg[3]={0};
int other;
float label2,label3;
while(!ifs1.eof()){
ifs1 >> label1;
ifs2 >> label2;
ifs3 >> label3;
ifs1 >> label1;
ifs2 >> label2;
ifs3 >> label3;
if(label1 < OTHER && label2 < OTHER && label3 <OTHER)
other++;
if(label1>label2){
if(label1>label3)
pos[0]++;
else
pos[2]++;
}
else if(label1<label2){
if(label2>label3)
pos[1]++;
else
pos[2]++;
}
ifs1 >> label1;
ifs2 >> label2;
ifs3 >> label3;
num++;
}
for(int i=1;i<=3;i++){
std::cout << i << ":" << (float)pos[i-1]/num*100 << " ";
}
std::cout << other << ":" <<(float)other/num*100 << " ";
std::cout << "\n";
}
int main(int argc, char **argv) {
Vocab3 vocab;
Splitter s(vocab,3,true);
s.load_vocab(argv[1]);
s.go();
NgramCounter unigrams(1);
ifstream ifs1(argv[1]);
LineTokenizer lt1(ifs1);
while(lt1.next()){
Tokenizer tok(lt1.token(),' ');
while(tok.next()){
int wid = vocab.Add(tok.token());
unigrams.increase_count(&wid,1);
}
}
ifstream ifs(argv[1]);
LineTokenizer lt(ifs);
NgramCounter ng(2);
while(lt.next()){
Tokenizer tok(lt.token(),' ');
while(tok.next()){
int wid = vocab.Add(tok.token());
int clid = s.get_class(wid);
if (clid < 0 || unigrams.get_count(&wid) > 100 ){
clid = wid;
}
else {
string cl = "-" + s.class_set.Get(clid).str();
clid = vocab.Add(LString(cl));
}
int key[2] = {clid,wid};
ng.increase_count(key,1);
cout << vocab.Get(clid) << " ";
}
cout << endl;
}
BtreeIterator it = ng.iterator();
ofstream ofs("my.classes");
while(it.next()){
ofs << vocab.Get(it.key()[1]) << "\t" << vocab.Get(it.key()[0]) << "\t" << (int)it.double_value()[0] << endl;
}
ofstream ofs2("my.classmap");
it = s.class_map.iterator();
while (it.next()){
ofs2 << vocab.Get(it.key()[0]) << "\t" << s.class_set.Get(it.key()[1]) << endl;
}
}
void Draw(){
gSystem->Load("../AnalysisLib/lib/libAnalysisLib.so");
IDHandler* handler = new IDHandler();
CsIImage* image = new CsIImage(handler);
TH1D* hisResidual = new TH1D("his","",80,-0.2,0.2);
std::ifstream ifs("CalibrationData/OldCalibrationData/CalibrationFactor_8.dat");
if( !ifs.is_open() ) return;
Double_t gainList[2716]= {1};
Double_t gainListSpec[2716]={1};
while( !ifs.eof() ){
int ID;
double gain;
ifs >> ID >> gain;
std::cout << ID << " : " << gain << std::endl;
gainList[ID] = gain;
}
std::ifstream ifs1("Data/calibConstKe3.dat");
while( !ifs1.eof()){
int ID;
double gain;
ifs1 >> ID >> gain;
gainListSpec[ID] = gain;
}
TGraph*gr = new TGraph();
for( int i = 0; i<2716; i++){
image->Fill(i,gainList[i]);
gr->SetPoint(gr->GetN(), gainList[i],gainListSpec[i]);
if( !gainList[i]==0){
hisResidual->Fill((gainList[i]-gainListSpec[i])/gainList[i]);
}
}
TCanvas* can = new TCanvas("can","",800,800);
//gr->Draw("AP");
//image->DrawWithRange("colz",0.8,1.2);
hisResidual->Fit("gaus","","",-0.03,0.06);
hisResidual->Draw();
//image->Draw();
}
void testResult(){
std::ifstream ifs0("simGain.txt");
std::ifstream ifs1("CalibrationN.txt");
if( !ifs0.is_open() ){return;}
if( !ifs1.is_open() ){return;}
TH1D* hisGain = new TH1D("test","",200,0,2);
TH1D* hisInit = new TH1D("test1","",200,0,2);
double cal0;
double cal1;
double calfactor0[2716]={0};
double calfactor1[2716]={0};
Int_t N;
Int_t ID;
while( !ifs0.eof() ){
ifs0 >> ID >> cal0;
calfactor0[ID] = cal0;
std::cout<< ID << std::endl;
}
while( !ifs1.eof() ){
ifs1 >> ID >> cal1 >> N;
std::cout<< ID << std::endl;
calfactor1[ID] = cal1;
}
for( int i = 0; i< 2716; i++){
if(calfactor0[i] ==0 || calfactor1[i] ==0){
continue;
}
hisGain->Fill(calfactor0[i]/calfactor1[i]);
hisInit->Fill(calfactor0[i]);
}
hisGain->Draw();
hisInit->SetLineColor(2);
hisInit->Draw("same");
std::cout<< hisGain->GetRMS()/hisGain->GetMean() << "\t"
<< hisInit->GetRMS()/hisInit->GetMean() << std::endl;
}
void Vocabulary::loadPretrainedVector(const std::string& file){
std::ifstream ifs1(file.c_str());
std::ifstream ifs2((file+".score").c_str());
assert(ifs1 && ifs2);
for (std::string line; std::getline(ifs1, line); ){
std::vector<std::string> res;
boost::split(res, line, boost::is_space());
std::unordered_map<std::string, int>::iterator it = this->nounIndices.find(res[0]);
if (it != this->nounIndices.end()){
for (int i = 0; i < this->wordDim; ++i){
this->nounVector.coeffRef(i, it->second) = atof(res[i+1].c_str());
}
}
it = this->contextIndices.find(res[0]);
if (it != this->contextIndices.end()){
for (int i = 0; i < this->wordDim; ++i){
this->contextVector.coeffRef(i, it->second) = atof(res[i+1].c_str());
}
}
}
for (std::string line; std::getline(ifs2, line); ){
std::vector<std::string> res;
boost::split(res, line, boost::is_space());
std::unordered_map<std::string, int>::iterator it = this->contextIndices.find(res[0]);
if (it != this->contextIndices.end()){
for (int i = 0; i < this->wordDim; ++i){
this->scoreVector.coeffRef(i, it->second) = atof(res[i+1].c_str());
}
}
}
}
int main(int argc, char* argv[])
{
std::string filename1, filename2;
po::options_description hidden("Hidden options");
hidden.add_options()
("input-file1", po::value<std::string>(&filename1), "The first collection of persistence diagrams")
("input-file2", po::value<std::string>(&filename2), "The second collection of persistence diagrams");
po::positional_options_description p;
p.add("input-file1", 1);
p.add("input-file2", 2);
po::options_description all; all.add(hidden);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).
options(all).positional(p).run(), vm);
po::notify(vm);
if (!vm.count("input-file1") || !vm.count("input-file2"))
{
std::cout << "Usage: " << argv[0] << " input-file1 input-file2" << std::endl;
std::cout << hidden << std::endl;
return 1;
}
std::ifstream ifs1(filename1.c_str()), ifs2(filename2.c_str());
boost::archive::binary_iarchive ia1(ifs1), ia2(ifs2);
std::map<Dimension, PDgm> dgms1, dgms2;
ia1 >> dgms1;
ia2 >> dgms2;
std::cout << "Distance between dimension 0: " << bottleneck_distance(dgms1[0], dgms2[0]) << std::endl;
std::cout << "Distance between dimension 1: " << bottleneck_distance(dgms1[1], dgms2[1]) << std::endl;
std::cout << "Distance between dimension 2: " << bottleneck_distance(dgms1[2], dgms2[2]) << std::endl;
}
CheckerGame::CheckerGame() : GameBase(8,8) {
ifstream ifs1(theGame);
if (!ifs1){
ofstream ofs(theGame);
ofs << "NO DATA" << endl;
}
ifstream ifs(theGame);
string data;
getline(ifs, data);
if (data == "NO DATA"){
string display;
ifstream defaultFile("checker0");
if (defaultFile){
GamePiece GameP;
while (getline(defaultFile, display)){
istringstream Iss(display);
for (int i = 0; i < 8; ++i){
Iss >> GameP.display;
XorO.push_back(GamePiece(Black, "emptyName", GameP.display));
}
}
}
else{
throw noSudokuFile;
void XMLScannerTest::run()
{
//create a dummy map with a fakie f*****g modulewhateverinfo....
std::vector<std::pair<std::string, std::string> > outs(1);
std::vector<std::pair<std::string, std::string> > ins(0);
std::pair<std::string, std::string> outpair("typ_string", "String");
outs[0] = outpair;
//Xpm dummy(dummyXpm, strlen(dummyXpm)+1);
ModuleInfo* mi = new ModuleInfo("mod_stringModule", "String",
ins, outs, true);
std::vector<std::pair<std::string, std::string> > outs2(0);
std::vector<std::pair<std::string, std::string> > ins2(1);
std::pair<std::string, std::string> inpair("typ_framebuffer", "Bild");
ins2[0] = inpair;
ModuleInfo* mi2 = new ModuleInfo("mod_glOutputModule", "GLoutput" ,
ins, outs, false);
std::vector<std::pair<std::string, std::string> > outs3(1);
std::vector<std::pair<std::string, std::string> > ins3(3);
std::pair<std::string, std::string> inpair2("typ_number","Zahl");
ins3[0] = inpair2;
ins3[1] = inpair2;
ins3[2] = inpair;
outs3[0] = inpair;
ModuleInfo* mi3 = new ModuleInfo("mod_tunnelModule", "Tunnel" ,
ins, outs, false);
std::map<int, ModuleInfo*> mi_map;
mi_map[0] = mi;
mi_map[1] = mi2;
mi_map[2] = mi3;
//create storage room for the listener
std::map<std::string, int> infos;
std::map<std::string, std::pair<int,int> > nodes;
std::map<int, std::string> nodeIDs;
std::map<std::string, std::pair<int,int> > controls;
std::map<int, std::string> controlIDs;
std::map<std::pair<int,int>, std::pair<int,int> > conns;
std::map<std::pair<int,int>, std::pair<int,int> > ctrlconns;
//create an xmlListener with that dummyinfo
XMLTokenListener horcher(mi_map, infos, nodes, nodeIDs, controls, controlIDs, conns, ctrlconns);
XMLFileScanner gucker(horcher);
std::ifstream ifs("testCorrect.graph");
if(ifs==0)
std::cout<<"File not found \n";
std::string testTextCorrect;
char tmp;
while(ifs.get(tmp))
{
testTextCorrect += tmp;
}
gucker.scan(testTextCorrect);
//eine datei ohne <model>
//std::cout<<"Processing incorrect file 1...\n";
std::ifstream ifs1("testInCorrect1.graph");
if(ifs1==0)
std::cout<<"File not found \n";
std::string testTextInCorrect1;
while(ifs.get(tmp))
{
testTextInCorrect1 += tmp;
}
try
{
gucker.scan(testTextInCorrect1);
}
catch(std::runtime_error err)
{
//if(err.what() != "This is no Ge-Phex Graph file...go f**k your dog!!!")
// throw std::runtime_error(err.what());
//std::cout<<err.what()<<std::endl;
}
//eine datei ohne </model>, ja, ich weiss, kreativ...
//std::cout<<"Processing incorrect file 2...\n";
std::ifstream ifs2("testInCorrect2.graph");
if(ifs2==0)
std::cout<<"File not found \n";
std::string testTextInCorrect2;
while(ifs2.get(tmp))
{
testTextInCorrect2 += tmp;
}
try
{
gucker.scan(testTextInCorrect2);
}
catch(std::runtime_error err)
{
//if(err.what() != "File has a wrong finishing tag...wrong format")
// throw std::runtime_error(err.what());
//std::cout<<err.what()<<std::endl;
}
//eine datei mit fehlender node section
//std::cout<<"Processing incorrect file 3...\n";
std::ifstream ifs3("testInCorrect3.graph");
if(ifs3==0)
std::cout<<"File not found \n";
std::string testTextInCorrect3;
while(ifs3.get(tmp))
{
testTextInCorrect3 += tmp;
}
try
{
gucker.scan(testTextInCorrect3);
}
catch(std::runtime_error err)
{
//if(err.what() != "File has wrong format...section nodes")
// throw std::runtime_error(err.what());
//std::cout<<err.what()<<std::endl;
}
}
static bool eval(int argc, char **argv) {
static const MeCab::Option long_options[] = {
{ "level", 'l', "0 -1", "STR", "set level of evaluations" },
{ "output", 'o', 0, "FILE", "set the output file name" },
{ "version", 'v', 0, 0, "show the version and exit" },
{ "help", 'h', 0, 0, "show this help and exit." },
{ 0, 0, 0, 0 }
};
MeCab::Param param;
param.open(argc, argv, long_options);
if (!param.open(argc, argv, long_options)) {
std::cout << param.what() << "\n\n" << COPYRIGHT
<< "\ntry '--help' for more information." << std::endl;
return -1;
}
if (!param.help_version()) return 0;
const std::vector<std::string> &files = param.rest_args();
if (files.size() < 2) {
std::cout << "Usage: " <<
param.program_name() << " output answer" << std::endl;
return -1;
}
std::string output = param.get<std::string>("output");
if (output.empty()) output = "-";
MeCab::ostream_wrapper ofs(output.c_str());
CHECK_DIE(*ofs) << "no such file or directory: " << output;
const std::string system = files[0];
const std::string answer = files[1];
const std::string level_str = param.get<std::string>("level");
std::ifstream ifs1(files[0].c_str());
std::ifstream ifs2(files[1].c_str());
CHECK_DIE(ifs1) << "no such file or directory: " << files[0].c_str();
CHECK_DIE(ifs2) << "no such file or directory: " << files[0].c_str();
CHECK_DIE(!level_str.empty()) << "level_str is NULL";
std::vector<int> level;
parseLevel(level_str.c_str(), &level);
CHECK_DIE(level.size()) << "level_str is empty: " << level_str;
std::vector<size_t> result_tbl(level.size());
std::fill(result_tbl.begin(), result_tbl.end(), 0);
size_t prec = 0;
size_t recall = 0;
std::vector<std::vector<std::string> > r1;
std::vector<std::vector<std::string> > r2;
while (true) {
if (!read(&ifs1, &r1, level) || !read(&ifs2, &r2, level))
break;
size_t i1 = 0;
size_t i2 = 0;
size_t p1 = 0;
size_t p2 = 0;
while (i1 < r1.size() && i2 < r2.size()) {
if (p1 == p2) {
for (size_t i = 0; i < result_tbl.size(); ++i) {
if (r1[i1][i] == r2[i2][i]) {
result_tbl[i]++;
}
}
p1 += r1[i1][0].size();
p2 += r2[i2][0].size();
++i1;
++i2;
++prec;
++recall;
} else if (p1 < p2) {
p1 += r1[i1][0].size();
++i1;
++prec;
} else {
p2 += r2[i2][0].size();
++i2;
++recall;
}
}
while (i1 < r1.size()) {
++prec;
++i1;
}
while (i2 < r2.size()) {
++recall;
++i2;
}
}
*ofs << " precision recall F"
<< std::endl;
for (size_t i = 0; i < result_tbl.size(); ++i) {
if (level[i] == -1) {
*ofs << "LEVEL ALL: ";
} else {
*ofs << "LEVEL " << level[i] << ": ";
}
printeval(&*ofs, result_tbl[i], prec, recall);
}
return true;
}
bool Read3DDataTest::ReadAndCompare(
const std::string& dcmInputNameEnd,
const std::string& vtkFileNameEnd,
const TYPE& inputType ) const
{
try
{
// Working directory of the test
const std::string dcmInputName = std::string(CISTIB_TOOLKIT_FOLDER) + dcmInputNameEnd;
const std::string vtkFileName = std::string(CISTIB_TOOLKIT_FOLDER) + vtkFileNameEnd;
// Check if the vtk file exists
std::ifstream ifs2( vtkFileName.c_str() );
TSM_ASSERT( "The input VTK file does not exist.", !ifs2.fail() );
if( ifs2.fail() ) return false;
ifs2.close();
// read input
vtkSmartPointer<vtkImageData> vtkDicomImage;
switch( inputType )
{
case FILE:
{
// Check if the dicom file exists
std::ifstream ifs1( dcmInputName.c_str() );
TSM_ASSERT( "The input DICOM file does not exist.", !ifs1.fail() );
if( ifs1.fail() ) return false;
ifs1.close();
// Read using dcmAPI::ImageUtilities
vtkDicomImage = dcmAPI::ImageUtilities::ReadVtkImageFromFile< unsigned short, 3 >(
dcmInputName.c_str(), true );
}
break;
case FOLDER:
{
// Check if the folder exists
if ( !boost::filesystem::exists( dcmInputName ) ) return false;
// create list of files
std::vector< std::string > dcmFileNames;
boost::filesystem::directory_iterator end_itr; // default construction yields past-the-end
for( boost::filesystem::directory_iterator itr( dcmInputName );
itr != end_itr; ++itr )
{
if( is_regular_file(itr->status()) && itr->leaf() != "DICOMDIR")
{
dcmFileNames.push_back( dcmInputName + "/" + itr->leaf() );
}
}
// sort the files alphabetically
std::sort(dcmFileNames.begin(), dcmFileNames.end());
// Read using dcmAPI::ImageUtilities
vtkDicomImage = dcmAPI::ImageUtilities::ReadMultiSliceVtkImageFromFiles< unsigned short, 3 >(
dcmFileNames, true );
}
break;
case DICOMDIR:
{
// Data set
dcmAPI::DataSet::Pointer dcmData = dcmAPI::DataSet::New();
// scan the current working folder for dicom files
dcmAPI::DataSetReader::Pointer reader = dcmAPI::DataSetReader::New( );
reader->SetDataSet( dcmData );
reader->ReadDicomDir( dcmInputName );
// Patient
const dcmAPI::Patient::Pointer patient = dcmData->GetPatient( dcmData->GetPatientIds()->at(0) );
// Study
const dcmAPI::Study::Pointer study = patient->Study( patient->StudyIds()->at(0) );
// Serie
const dcmAPI::Series::Pointer series = study->Series( study->SeriesIds()->at(0) );
// TimePoint
const dcmAPI::TimePoint::Pointer timePoint = series->TimePoint( series->TimePointIds()->at(0) );
// Slice
const dcmAPI::SliceIdVectorPtr sliceIdVector = timePoint->SliceIds();
std::vector< std::string > dcmFileNames;
for( unsigned int i=0; i < sliceIdVector->size(); ++i)
{
const dcmAPI::Slice::Pointer slice = timePoint->Slice(sliceIdVector->at(i));
const std::string filePath = slice->GetTagAsText(dcmAPI::tags::SliceFilePath);
dcmFileNames.push_back( filePath );
}
// Read using dcmAPI::ImageUtilities
vtkDicomImage = dcmAPI::ImageUtilities::ReadMultiSliceVtkImageFromFiles< unsigned short, 3 >(
dcmFileNames, true );
}
break;
default:
{
TS_FAIL("Read3DDataTest::ReadAndCompare failed: unknwown case.");
return false;
}
}
// Read using BaseLib
vtkSmartPointer<vtkImageData> vtkImage = blImageUtils::LoadImageFromFileAsVTK( vtkFileName.c_str() );
// Compare image content
return blImageUtils::CompareImages( vtkDicomImage, vtkImage, 1e-5 );
}
catch(...)
{
TS_FAIL("Read3DDataTest::ReadAndCompare failed: thrown exception.");
return false;
}
}
int main(int argc, char ** argv){
// check input
if(argc < 3){
std::cout << "Usage: difference <file1.g2o> <file2.g2o>" << std::endl;
return 0;
}
init();
// allocate the optimizers
g2o::SparseOptimizer * optimizer1 = new g2o::SparseOptimizer();
g2o::SparseOptimizer * optimizer2 = new g2o::SparseOptimizer();
SlamLinearSolver* linearSolver = new SlamLinearSolver();
linearSolver->setBlockOrdering(false);
SlamBlockSolver* blockSolver = new SlamBlockSolver(linearSolver);
g2o::OptimizationAlgorithmGaussNewton* solver = new g2o::OptimizationAlgorithmGaussNewton(blockSolver);
optimizer1->setAlgorithm(solver);
optimizer2->setAlgorithm(solver);
// load the graphs
std::ifstream ifs1(argv[1]);
std::ifstream ifs2(argv[2]);
if(!ifs1){
std::cout << "Cannot open file " << argv[1] << std::endl;
return 1;
}
if(!ifs2){
std::cout << "Cannot open file " << argv[2] << std::endl;
return 1;
}
if(!optimizer1->load(ifs1)){
std::cout << "Error loading graph #1" << std::endl;
return 2;
}
if(!optimizer2->load(ifs2)){
std::cout << "Error loading graph #2" << std::endl;
return 2;
}
std::cout << "graph #1:";
std::cout << "\tLoaded " << optimizer1->vertices().size() << " vertices" << std::endl;
std::cout << "\tLoaded " << optimizer1->edges().size() << " edges" << std::endl;
std::cout << "graph #2:";
std::cout << "\tLoaded " << optimizer1->vertices().size() << " vertices" << std::endl;
std::cout << "\tLoaded " << optimizer1->edges().size() << " edges" << std::endl;
g2o::HyperGraph::VertexIDMap map1 = optimizer1->vertices();
g2o::HyperGraph::VertexIDMap map2 = optimizer2->vertices();
// safety checks
std::cout << "safety checks...";
if(optimizer1->vertices().size() != optimizer2->vertices().size()){
std::cout << "!!! the two graphs don't have the same number of vertices !!!" << std::endl;
return 3;
}
for(g2o::HyperGraph::VertexIDMap::iterator it=map1.begin(); it!=map1.end(); it++){
g2o::OptimizableGraph::Vertex * v1 = (g2o::OptimizableGraph::Vertex *) it->second;
int dim = v1->minimalEstimateDimension();
if(dim!=3 & dim!=2){
std::cerr << "Vertex #" << v1->id() << " has strange dimension: " << dim << std::endl;
return 4;
}
// get the corresponding vertex in the other graph
g2o::OptimizableGraph::Vertex * v2 = (g2o::OptimizableGraph::Vertex *) map2[v1->id()];
assert(v2->id() == v1->id());
if(v2->minimalEstimateDimension() != dim){
std::cerr << "ERROR: vertex " << v2->id() << " has different dimension in the two graphs" << std::endl;
return 5;
}
}
std::cout << "done" << std::endl;
std::vector<g2o::OptimizableGraph::Vertex*> vertices;
for(g2o::HyperGraph::VertexIDMap::iterator it=map1.begin(); it!=map1.end(); it++){
vertices.push_back((g2o::OptimizableGraph::Vertex *)it->second);
}
std::cout << "vertices vector filled" << std::endl;
bool visited[vertices.size()];
for(unsigned int i=0; i<vertices.size(); i++){
visited[i] = false;
}
thread_struct t_struct;
t_struct.map1 = &map1;
t_struct.map2 = &map2;
t_struct.vertices = &vertices;
t_struct.visited = visited;
pthread_t threads[_num_threads + 1];
for(unsigned int i=0; i<_num_threads; i++){
pthread_create(threads+i, NULL, launch_analyze, &t_struct);
}
visualizer_struct v_struct;
v_struct.visited = visited;
v_struct.size = vertices.size();
pthread_create(threads+_num_threads, NULL, launch_visualize, &v_struct);
std::cout << "threads launched" << std::endl;
for(unsigned int i=0; i<_num_threads+1; i++){
pthread_join(threads[i], NULL);
}
std::cout << "minimum error = " << _best_error;
}
/* ********************************************
* reweighting and pmf calculation at room temperature
* ********************************************/
int main(int argc, char *argv[]){
// INPUT_PARAMETERS
// argv[1]: input parameter file
if( argv[1]==NULL ){
puts("No ARGUMEMTS");
puts("USAGE: ./a.out (argv[1]: input parameter file)" );
return 1;
}
cout<<"Your input-parameter file: "<<argv[1]<<endl;
Inp_nishi inp1( argv[1] );
// ############# READ INPUT ########################################
/* (1)
*
*/
cout<<endl<<"------- (1) load --------- \n";
string infile = inp1.read("INFILE");
string inprob = inp1.read("INPROB");
cout<<"# output"<<endl;
string outpmf = inp1.read("OUTPMF");
cout<<"# settings"<<endl;
int frame = atoi( inp1.read("NUMSTRUCTURE").c_str() );
/* DEFINITION OF VARIABLES
*/
vector<long double> prob2; //probability of each data
vector<long double> ene_prob, prob; //from inprob (Pc) Probability distribution function along potential energy
int outlier = 0; //num of data out of energy range
/* OPEN FILE
*/
//float tmp;
long double tmp;
ifstream ifs1(infile.c_str());
//ifstream ifs1(infile.c_str(),ifstream::in);
if(ifs1.fail()){
cerr<<"cannot open file "<<infile<<endl;
//exit(1);
return 1;
}
vector<float> c1, c2, pote;
//while(!ifs.eof()){
//while(ifs.good()){
for(int ii=0;ii<frame;ii++){
ifs1 >> tmp;
c1.push_back(tmp);
ifs1 >> tmp;
c2.push_back(tmp);
ifs1 >> tmp;
pote.push_back(tmp);
}
ifs1.close();
//cout<<"DEBUG: pote.size() = "<<pote.size()<<endl;
//cout<<"DEBUG: pote[pote.size() -1] = "<<pote[pote.size() -1]<<endl;
/* (2) assignment of probability
*
* */
// read file
ifstream test(inprob.c_str());
//ifstream test(inprob.c_str(),ifstream::in);
if(inprob == "NO") goto flag_noprob; //assign probability
{ // goto flag_noprob
if(test.fail()){
cerr<<"cannot open file "<<inprob<<endl;
//exit(1);
return 1;
}
//test.clear();
//test.seekg(2);
test >> tmp; //why outside of while-loop? because of ifs.eof
//cerr<<"DEBUG: tmp of ene_prob = "<<tmp<<endl;
//for(int ii=0;ii<2131;ii++){
//while( true ){
while( ! test.eof() ){
//while(test.good()){
//test >> tmp;
//if( test.eof() ) break;
//cerr<<"DEBUG: tmp of ene_prob = "<<tmp<<endl;
ene_prob.push_back(tmp);
test >> tmp;
prob.push_back(tmp);
test >> tmp;
}
test.close();
//cout<<"DEBUG: ene_prob.size() = "<<ene_prob.size()<<endl;
cout<<" reading input section end "<<endl;
//cout<<"DEBUG: prob.size() = "<<prob.size()<<endl;
//cout<<"DEBUG: prob[prob.size() -1] = "<<prob[prob.size() -1]<<endl;
//cout<<"DEBUG: ene_prob.size() = "<<ene_prob.size()<<endl;
//cout<<"DEBUG: ene_prob[ene_prob.size() -1] = "<<ene_prob[prob.size() -1]<<endl;
//ttp_v_mcmd input
string inttpin = inp1.read("INTTPIN"); //ttp_v_mcmd.inp
string inttpout = inp1.read("INTTPOUT"); //ttp_v_mcmd.out
int interval = atoi( inp1.read("INTERVAL").c_str() );
vector<float> tmpvec;
ifstream ttpvinp(inttpin.c_str()); //ttp_v_mcmd.inp
if( ttpvinp.fail() ){
cerr<<"cannot open file "<<inttpin<<endl;
return 1;
}
while( ttpvinp ){
string tmpstr;
ttpvinp >> tmpstr;
//cout<< tmpstr<<endl;
if( tmpstr[0] == ';' ){
ttpvinp.ignore(100, '\n');
}
else{
tmpvec.push_back( atof( tmpstr.c_str() ) );
}
}
ttpvinp.close();
/*for(unsigned int i;i<tmpvec.size();i++){
cout<<tmpvec[i]<<endl;
}*/
int vst = tmpvec[0];
int trans = tmpvec[1];
vector<float> ttplimit;
for(int i=1;i<=vst;i++){
ttplimit.push_back( tmpvec[4*i-2] );
ttplimit.push_back( tmpvec[4*i-1] );
}
/*for(unsigned int i;i<ttplimit.size();i++){
cout<<ttplimit[i]<<endl;
}*/
tmpvec.clear();
vector<int> currvst;
ifstream ttpvout(inttpout.c_str()); //ttp_v_mcmd.out
if( ttpvout.fail() ){
cerr<<"cannot open file "<<inttpout<<endl;
return 1;
}
while( ttpvout ){
ttpvout >> tmp;
ttpvout >> tmp;
//cout<<tmp<<endl;
currvst.push_back( tmp );
}
/*for(unsigned int i;i<currvst.size();i++){
cout<<currvst[i]<<endl;
}*/
ttpvout.close();
//
cout<<endl<<"------- (2) assignment of probability --------- \n";
int check_flat[ene_prob.size()];
for(unsigned int i=0;i<ene_prob.size();i++){
check_flat[i] = 0; //initializing by zero
}
//trans/interval
int iii=0;
for(int ii=0;ii<frame;ii++){
int flag_1 = 0;
unsigned int jj = 0;
int vstnum = currvst[int(ii/20)];
//cout<<int(ii/20)<<" "<<vstnum<<endl;
if( pote[ii] < ttplimit[2*vstnum-2] || pote[ii]>=ttplimit[2*vstnum-1] ){
prob2.push_back( 0 );
outlier ++ ;
continue;
}
else if( pote[ii] < ene_prob[0] || pote[ii] >= ene_prob[ene_prob.size() - 1]){
prob2.push_back( 0 );
outlier ++ ;
continue;
}
else{
for(jj=0;jj<ene_prob.size();jj++){
if( pote[ii] < ene_prob[jj] ){
prob2.push_back( prob[jj] );
if( vstnum == 1 || vstnum == vst ){
check_flat[jj] ++ ;
}
check_flat[jj] ++ ;
flag_1 = 1;
break;
}
}
}
//if( jj==ene_prob.size() ){
//if( pote[ii] >= ene_prob[ene_prob.size() - 1]){
//if( flag_1 == 0 ){
//cout<<"WARNING: pote["<<ii<<"] = "<<pote[ii]<<endl;
//prob2.push_back( prob[ jj - 1 ] );
//check_flat[jj - 1 ] ++ ;
//}
}
if( prob2.size() != frame ){
cout<<"ERROR: assignment of probability failed \n";
cout<<"num of assigned = "<<prob2.size()<<endl;
cout<<"num of structures = "<<frame<<endl;
return 1;
}
else{
cout<<"assignment of probability was ended successfully"<<endl;
cout<<"num of outliers = "<<outlier<<endl;
}
string outcheck = inp1.read("OUTCHECK").c_str() ;
if( outcheck != "NO" ){
ofstream ofs2; //check_flat
//ofs2.open( inp1.read("OUTCHECK").c_str() );
ofs2.open( outcheck.c_str() );
for(unsigned int i = 0;i<ene_prob.size();i++){
ofs2<<ene_prob[i]<<" "<<check_flat[i]<<"\n";
}
ofs2.close();
cout<<endl<<outcheck<<" was output successfully"<<endl;
}
} // end of goto flag_noprob
flag_noprob:
if(inprob == "NO"){
for(int ii=0;ii<frame;ii++){
prob2.push_back(1);
}
}
/* OUTPUT FILE
*/
ofstream ofs1;
ofs1.open( inp1.read("OUTPROB").c_str() );
for(unsigned int i = 0;i<prob2.size();i++){
ofs1<<prob2[i]<<"\n";
}
ofs1.close();
/* (7) PMF calculation
*
* */
cout<<endl<<"REPORT> (7) PMF calculation \n";
float dcbound1 = atof( inp1.read("DCBOUND1").c_str() );
float dcbound2 = atof( inp1.read("DCBOUND2").c_str() );
//string pmfcalculation = inp1.read("PMFCALCULATION");
string pmfcalculation = "YES";
if( pmfcalculation == "YES" ){
double length_bin = atof(inp1.read("BINSIZE").c_str());
float emin = atof(inp1.read("MINCOORD").c_str());
float temperature = atof(inp1.read("TEMPERATURE").c_str());
int num_bin = atoi(inp1.read("NUMBIN").c_str());
cout<<"Range: "<<emin<<" to "<<emin+length_bin*num_bin<<endl;
cout<<"Num of Partitions = NUMBIN*NUMBIN = "<<num_bin*num_bin<<endl;
//float pmf[num_bin][num_bin];
double pmf[num_bin][num_bin];
//long double pmf[num_bin][num_bin];
for(int i=0;i<num_bin;i++){ //initialize array
for(int j=0;j<num_bin;j++){
pmf[j][i] = 0;
}
}
int count_pmf = 0; long double normcons = 0;
int count_valid = 0;
for(unsigned int n=0;n<frame;n++){ //count
int flag_2 = 0;
for(int i=0;i<num_bin;i++){
bool flag_3 = false;
for(int j=0;j<num_bin;j++){
if(c1[n] >= emin + length_bin * j
&& c1[n] < emin + length_bin * (j + 1)
&& c2[n] >= emin + length_bin * i
&& c2[n] < emin + length_bin * (i + 1) ){
//pmf[j][i] ++ ;
if( prob2[n] > 0 ){
count_valid ++ ;
}
if( pote[n] < dcbound1 || pote[n] > dcbound2 ){
pmf[j][i] = pmf[j][i] + prob2[n]*2 ; //counting by probability
normcons = normcons + prob2[n]*2; //normalization constant
}
else{
pmf[j][i] = pmf[j][i] + prob2[n] ; //counting by probability
normcons = normcons + prob2[n]; //normalization constant
}
count_pmf ++ ; //counting 1 by 1
//goto NEXT_PMF;
flag_3 = true;
flag_2 = 1;
break;
}
}
if( flag_3 ) break;
}
if( flag_2 == 0 ){
cout<<"WARNING: structure "<<n<<" was not assigned into any bin of pmf\n";
cout<<"c1[n] = "<<c1[n]<<", c2[n] = "<<c2[n]<<endl;
}
}
cout<<"Normaliztion constant = "<<normcons<<endl;
cout<<"The number of data whose probability is larger than zero = "<<count_valid<<endl;
cout<<"count_pmf / frame = "<<count_pmf<<" / "<<frame<<endl;
if( count_pmf != (int)frame )cout<<"WARNING: count_pmf != frame; "<<count_pmf<<" != "<<frame<<endl;
double min_pmf = 999999, max_pmf = -999999;
for(int i=0;i<num_bin;i++){ //normalization
for(int j=0;j<num_bin;j++){
//pmf[j][i] = pmf[j][i] / frame;
pmf[j][i] = pmf[j][i] / normcons;
if( pmf[j][i] <= min_pmf ){
min_pmf = pmf[j][i];
}
if( pmf[j][i] >= max_pmf ){
max_pmf = pmf[j][i];
}
}
}
cout<<"Maximum Probability = "<<max_pmf<<endl;
cout<<"Minimum Probability = "<<min_pmf<<endl;
//double const_boltz = 1.380658e-23, pmf_temp = 300;
min_pmf = 999999, max_pmf = -999999;
int min_pmf_n[2]; double min_pmf_c[2];
min_pmf_n[0] = 0; min_pmf_n[1] = 0;
int max_pmf_n[2]; double max_pmf_c[2];
max_pmf_n[0] = 0; max_pmf_n[1] = 0;
for(int i=0;i<num_bin;i++){ //PMF calculation
for(int j=0;j<num_bin;j++){
if( pmf[j][i] == 0 ){
//pmf[j][i] = 100;
continue;
}
pmf[j][i] = -1 * BOLTZMAN_CONST * temperature * log( pmf[j][i] );
if( pmf[j][i] < min_pmf ){
min_pmf = pmf[j][i];
min_pmf_n[0] = j; min_pmf_n[1] = i;
}
if( pmf[j][i] > max_pmf ){
max_pmf = pmf[j][i];
max_pmf_n[0] = j; max_pmf_n[1] = i;
//cout<<"DEBUG> max_pmf = "<<max_pmf<<", max_pmf_n[0], max_pmf_n[1] = "<<max_pmf_n[0]<<", "<<max_pmf_n[1]<<endl;
}
}
}
/*min_pmf_c[0] = emin + min_pmf_n[0] * length_bin + length_bin / 2;
min_pmf_c[1] = emin + min_pmf_n[1] * length_bin + length_bin / 2;
max_pmf_c[0] = emin + max_pmf_n[0] * length_bin + length_bin / 2;
max_pmf_c[1] = emin + max_pmf_n[1] * length_bin + length_bin / 2;*/
min_pmf_c[0] = emin + min_pmf_n[0] * length_bin ;
min_pmf_c[1] = emin + min_pmf_n[1] * length_bin ;
max_pmf_c[0] = emin + max_pmf_n[0] * length_bin ;
max_pmf_c[1] = emin + max_pmf_n[1] * length_bin ;
cout<<"Maximum PMF = "<<max_pmf-min_pmf<<" (J/mol) = "<<(max_pmf-min_pmf)/JOULE_CALORIE/1000<<" (kcal/mol)\n";
cout<<"Minimum PMF = "<<min_pmf-min_pmf<<" (J/mol) = "<<(min_pmf-min_pmf)/JOULE_CALORIE/1000<<" (kcal/mol)\n";
cout<<"(c1, c2) of Maximum PMF = ("<<max_pmf_c[0]<<", "<<max_pmf_c[1]<<")\n";
cout<<"(c1, c2) of Minimum PMF = ("<<min_pmf_c[0]<<", "<<min_pmf_c[1]<<")\n";
FILE *fout;
string outpmf = inp1.read("OUTPMF");
if((fout = fopen( outpmf.c_str(),"w" )) == NULL ){
printf("cannot open output file: %s\n", outpmf.c_str() );
return 1;
}
//for R format
/*for(int i=0;i<num_bin;i++){
fprintf(fout,"%12.3f ", emin+ length_bin * i);
}
fprintf(fout,"\n");
for(int i=0;i<num_bin;i++){
fprintf(fout,"%12.3f ",emin+ length_bin * i);
for(int j=0;j<num_bin;j++){
if( pmf[j][i] == 0L ){
fprintf(fout,"%12.3f ", 1000.0 );
}
else{
fprintf(fout,"%12.3f ", (pmf[j][i] - min_pmf) / JOULE_CALORIE /1000L );
}
}
fprintf(fout,"\n");
}*/
//for gnuplot format
for(int i=0;i<num_bin;i++){
for(int j=0;j<num_bin;j++){
if( pmf[j][i] == 0L ){
fprintf(fout,"%12.3f%12.3f%12.3f \n", emin + length_bin * j , emin + length_bin * i , 1000.0 );
}
else{
fprintf(fout,"%12.3f%12.3f%12.3lf \n", emin + length_bin * j , emin + length_bin * i , (pmf[j][i] - min_pmf) / JOULE_CALORIE /1000L );
}
}
fprintf(fout,"\n");
}
fclose( fout );
cout<<"output "<<outpmf<<endl;
//end:
/* structure list
*/
cout<<"\n\nWrite structure-number of minimum PMF bin \n";
for(unsigned int n=0;n<frame;n++){ //count
/*if(c1[n] > min_pmf_c[0] - length_bin / 2
&& c1[n] <= min_pmf_c[0] + length_bin / 2
&& c2[n] > min_pmf_c[1] - length_bin / 2
&& c2[n] <= min_pmf_c[1] + length_bin / 2 ){*/
if(c1[n] > min_pmf_c[0]
&& c1[n] <= min_pmf_c[0] + length_bin
&& c2[n] > min_pmf_c[1]
&& c2[n] <= min_pmf_c[1] + length_bin
&& prob2[n] > 0 ){
cout<<n+1<<" "<<pote[n]<<" "<<prob2[n]<<endl;
}
}
// END
}
cout<<"\n\nit took "<<(float)clock()/CLOCKS_PER_SEC<<" sec of CPU to execute this program"<<endl;
return 0;
return 0;
}
int main(int argc, char** argv)
{
try{
//Maybe initialize Mpi
Dune::MPIHelper& helper = Dune::MPIHelper::instance(argc, argv);
std::cout << "Hello World! This is dune-iris-opm." << std::endl;
if(Dune::MPIHelper::isFake)
{
std::cout<< "This is a sequential program." << std::endl;
/*-----------------------------------------------------------------------------*/
// The main program.
//----------------------------------------------------------------
//A) Must read necessary input stuff from files...
//----------------------------------------------------------------
PMTwoPhaseSimulationData simulationData;
simulationData.readPMTwoPhaseSimulationData();
//----------------------------------------------------------------
//B) Must do necessary stuff connected to the dune-grid:
//----------------------------------------------------------------
//@HAF: Now tries to structure this code such that it can also work for other types of dune-grids
//NOTE: DuneGridType is defined in IrisOpmTdefs.h
//NOTE2: This does NOT work yet...only Sgrid can be used yet!
//#ifdef SGridToBeUsed
cout << endl;
cout << simulationData.td_.NameOfGridType << endl;
cout << simulationData.td_.NoGridCells_X << endl;
cout << simulationData.td_.NoGridCells_Y << endl;
// DuneGridType* DGridPtr;
//if (simulationData.td_.NameOfGridType == "SGrid2D")
//{
const int dim=2;
Dune::FieldVector<int,dim> N(2);
//Puts the correct number of grid-blocks in each direction:
N[0] = simulationData.td_.NoGridCells_X; //@HAF: OK???
N[1] = simulationData.td_.NoGridCells_Y; //@HAF: OK???
//The geometrical size of the domain:
Dune::FieldVector<DuneGridType::ctype,dim> L(0.0);
Dune::FieldVector<DuneGridType::ctype,dim> H(1.0);
H[0] = simulationData.td_.X_Extent; //@HAF: OK???
H[1] = simulationData.td_.Y_Extent; //@HAF: OK???
//Creates the SGrid:
DuneGridType Dgrid(N,L,H);
//DGridPtr = &Dgrid;
//}
//#endif //SGridToBeUsed
#ifdef AluGridToBeUsed
if (simulationData.td_.NameOfGridType == "ALUGridSimplex2D")
{
Opm::GridFactory<DuneGridType> factory();
//Must fill in the vertices and elements from Triangle:
//insertVertices( factory, "A.1.node");
//insertSimplices( factory, "A.1.ele");
//Vertices:
Dune::FieldVector<double,2> pos;
double x,y,dummy;
int AnzKnoten;
std::ifstream ifs("A.1.node");
if (ifs.is_open()) {
ifs >> AnzKnoten >> dummy >> dummy >> dummy;
for (int i = 0; i < AnzKnoten; i++) {
ifs >> dummy >> x >> y >> dummy >> dummy;
pos[0] = x; pos[1] = y;
factory.insertVertex(pos);
}
ifs.close();
}
else
std::cout << "Error: Can not open file\n";
//Elements:
unsigned int numberOfSimplices, corner1, corner2, corner3, dummy1;
const Dune::GeometryType type( Dune::GeometryType::simplex, 2);
std::vector< unsigned int > cornerIDs( 3 );
std::ifstream ifs1("A.1.ele");
if (ifs1.is_open()) {
ifs1 >> numberOfSimplices >> dummy1 >> dummy1;
for (unsigned int i = 0; i < numberOfSimplices; i++) {
ifs1 >> dummy1 >> corner1 >> corner2 >> corner3;
cornerIDs[0] = corner1 - 1;
cornerIDs[1] = corner2 - 1;
cornerIDs[2] = corner3 - 1;
factory.insertElement(type, cornerIDs);
}
ifs1.close();
}
int main() {
ColoredGraph<GraphVertex,TriColor> gr;
set<GraphVertex,less<GraphVertex> > groupsall, filesall,functionsall;
set<GraphVertex,less<GraphVertex> > groupssome, filessome,functionssome,S;
set<GraphVertex,less<GraphVertex> > groupsnot, filesnot,functionsnot;
ifstream ifs1("groups.txt");
ifstream ifs2("files.txt");
ifstream ifs3("files.txt");
ifstream ifs4("choices.txt");
cerr << "reading groups";
readDoubleColumnGraph(ifs1,groupsall,gr,true);
cerr << ", files";
readDoubleColumnGraph(ifs2,filesall,gr,true);
cerr << ", functions\n";
readDoubleColumnGraph(ifs3,functionsall,gr,false);
readSingleColumn(ifs4,gr);
#if 1
ifstream ifs5("depends.txt");
list<list<string> > dbllist;
readMultiColumns(ifs5,dbllist);
#endif
bool todo = true;
while(todo) {
todo = false;
gr.ColorChildComponents(TriColor::s_one,TriColor::s_two);
list<GraphVertex> L(gr.getColored(TriColor::s_two));
copy(L.begin(),L.end(),inserter(S,S.begin()));
#if 1
todo = addElements(gr,TriColor::s_one,S,dbllist);
cerr << "addelements give " << todo << '\n';
#endif
};
cerr << "Here is the set after the loop:\n";
printset(cerr,S,",");
set_intersection(S.begin(),S.end(),groupsall.begin(),groupsall.end(),
inserter(groupssome,groupssome.begin()));
set_intersection(S.begin(),S.end(),filesall.begin(),filesall.end(),
inserter(filessome,filessome.begin()));
set_intersection(functionsall.begin(),functionsall.end(),S.begin(),S.end(),
inserter(functionssome,functionssome.begin()));
set_difference(groupsall.begin(),groupsall.end(),S.begin(),S.end(),
inserter(groupsnot,groupsnot.begin()));
set_difference(filesall.begin(),filesall.end(),S.begin(),S.end(),
inserter(filesnot,filesnot.begin()));
set_difference(functionsall.begin(),functionsall.end(),S.begin(),S.end(),
inserter(functionsnot,functionsnot.begin()));
cerr << "all groups:\n";
printset(cerr,groupsall,", ");
cerr << "\nall files:\n";
printset(cerr,filesall,", ");
cerr << "\nall functions:\n";
printset(cerr,functionsall,", ");
cerr << "\n\n\n";
cerr << "groups (not):\n";
printset(cerr,groupsnot,", ");
cerr << "\nfiles (not):\n";
printset(cerr,filesnot,", ");
cerr << "\nfunctions(not):\n";
printset(cerr,functionsnot,", ");
cerr << "\n\n\n";
cerr << "groups:\n";
printset(cerr,groupssome,", ");
cerr << "\nfiles:\n";
printset(cerr,filessome,", ");
cerr << "\nfunctions:\n";
printset(cerr,functionssome,", ");
cerr << "Staring creation of the file Makefile.mark\n";
ofstream ofs("Makefile.mark");
ofs << "p9clist = ";
printset(ofs,filessome,".o \\\n",".o \n");
ofs.close();
cerr << "Ended creation of the file Makefile.mark\n";
cerr << "Staring creation of the file Makefile.cp\n";
ofstream ofs2("Makefile.cp");
ofs2 << "cp ";
printset(ofs2,filessome,".[hc]pp copyplace/ \n cp ",".[hc]pp copyplace/ \n");
ofs2.close();
cerr << "Ended creation of the file Makefile.cp\n";
};
int
test_main(int /* argc */, char * /* argv */[]) {
std::locale old_loc;
std::locale * utf8_locale
= boost::archive::add_facet(
old_loc,
new boost::archive::detail::utf8_codecvt_facet
);
typedef char utf8_t;
typedef test_data<sizeof(wchar_t)> td;
// Send our test UTF-8 data to file
{
std::ofstream ofs;
ofs.open("test.dat", std::ios::binary);
std::copy(
td::utf8_encoding,
#if ! defined(__BORLANDC__)
// borland 5.60 complains about this
td::utf8_encoding + sizeof(td::utf8_encoding) / sizeof(unsigned char),
#else
// so use this instead
td::utf8_encoding + 12,
#endif
boost::archive::iterators::ostream_iterator<utf8_t>(ofs)
);
}
// Read the test data back in, converting to UCS-4 on the way in
std::vector<wchar_t> from_file;
{
std::wifstream ifs;
ifs.imbue(*utf8_locale);
ifs.open("test.dat");
wchar_t item = 0;
// note can't use normal vector from iterator constructor because
// dinkumware doesn't have it.
for(;;) {
item = ifs.get();
if(item == WEOF)
break;
//ifs >> item;
//if(ifs.eof())
// break;
from_file.push_back(item);
}
}
// compare the data read back in with the orginal
#if ! defined(__BORLANDC__)
// borland 5.60 complains about this
BOOST_CHECK(from_file.size() == sizeof(td::wchar_encoding)/sizeof(wchar_t));
#else
// so use this instead
BOOST_CHECK(from_file.size() == 6);
#endif
BOOST_CHECK(std::equal(from_file.begin(), from_file.end(), td::wchar_encoding));
// Send the UCS4_data back out, converting to UTF-8
{
std::wofstream ofs;
ofs.imbue(*utf8_locale);
ofs.open("test2.dat");
std::copy(
from_file.begin(),
from_file.end(),
boost::archive::iterators::ostream_iterator<wchar_t>(ofs)
);
}
// Make sure that both files are the same
{
typedef boost::archive::iterators::istream_iterator<utf8_t> is_iter;
is_iter end_iter;
std::ifstream ifs1("test.dat");
is_iter it1(ifs1);
std::vector<utf8_t> data1;
std::copy(it1, end_iter, std::back_inserter(data1));
std::ifstream ifs2("test2.dat");
is_iter it2(ifs2);
std::vector<utf8_t> data2;
std::copy(it2, end_iter, std::back_inserter(data2));
BOOST_CHECK(data1 == data2);
}
// some libraries have trouble that only shows up with longer strings
wchar_t * test3_data = L"\
<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
<!DOCTYPE boost_serialization>\
<boost_serialization signature=\"serialization::archive\" version=\"3\">\
<a class_id=\"0\" tracking_level=\"0\">\
<b>1</b>\
<f>96953204</f>\
<g>177129195</g>\
<l>1</l>\
<m>5627</m>\
<n>23010</n>\
<o>7419</o>\
<p>16212</p>\
<q>4086</q>\
<r>2749</r>\
<c>-33</c>\
<s>124</s>\
<t>28</t>\
<u>32225</u>\
<v>17543</v>\
<w>0.84431422</w>\
<x>1.0170664757130923</x>\
<y>tjbx</y>\
<z>cuwjentqpkejp</z>\
</a>\
</boost_serialization>\
";
// Send the UCS4_data back out, converting to UTF-8
std::size_t l = std::wcslen(test3_data);
{
std::wofstream ofs;
ofs.imbue(*utf8_locale);
ofs.open("test3.dat");
std::copy(
test3_data,
test3_data + l,
boost::archive::iterators::ostream_iterator<wchar_t>(ofs)
);
}
// Make sure that both files are the same
{
std::wifstream ifs;
ifs.imbue(*utf8_locale);
ifs.open("test3.dat");
BOOST_CHECK(
std::equal(
test3_data,
test3_data + l,
boost::archive::iterators::istream_iterator<wchar_t>(ifs)
)
);
}
delete utf8_locale;
return EXIT_SUCCESS;
}
