void calcEscaleSystematics(TString lumiTag="DY_j22_19712pb",
int saveTexTable=0){
int nUnfoldingBins = DYTools::getTotalNumberOfBins();
TVectorD observedYields(nUnfoldingBins);
TVectorD observedYieldsErr(nUnfoldingBins);
TVectorD dummyArr(nUnfoldingBins);
TVectorD unfoldedYields(nUnfoldingBins);
//
// Indicators (and also counters) whether the data was present
//
int countEScaleSyst=0;
int countResidualShape=0;
int countEtaSyst=0;
int countFittingShape=0;
std::vector<TString> usedFiles;
ElectronEnergyScale escale("Date20120802_default");
//
// Calculate error associated with statistical
// uncertainty on the energy scale factors
//
TVectorD unfoldedYieldsMean(nUnfoldingBins);
TVectorD unfoldedYieldsRMS(nUnfoldingBins);
TVectorD unfoldedYieldsSquaredMean(nUnfoldingBins);
unfoldedYieldsMean = 0;
unfoldedYieldsRMS = 0;
unfoldedYieldsSquaredMean = 0;
TString matrixFileName = TString("../root_files/constants/") + lumiTag +
TString("/detResponse_unfolding_constants") + DYTools::analysisTag + TString("_PU.root");
const int nFiles1 = 20; // expected number of files
if (1)
for(int ifile=0; ifile<nFiles1; ifile++){
int seed = 1001+ifile;
escale.randomizeEnergyScaleCorrections(seed);
TString fname = TString("../root_files/yields/") + lumiTag +
TString("_escale_randomized/yields_bg-subtracted") + DYTools::analysisTag +
TString("__") + escale.calibrationSetShortName();
fname += ".root";
TFile file(fname);
if (!file.IsOpen()) {
std::cout << "failed to open a file <" << fname << ">\n";
}
else {
file.Close();
// register
usedFiles.push_back(fname);
// work with data
int res= (readData(fname, observedYields,observedYieldsErr,dummyArr) == 1)
&& (applyUnfoldingLocal(observedYields,unfoldedYields,matrixFileName) == 1);
if (res==1) {
countEScaleSyst++;
//std::cout << "unfoldedYields for seed=" << seed << ": "; unfoldedYields.Print();
// Accumulate mean and RMS
for(int idx = 0; idx < nUnfoldingBins; idx++){
unfoldedYieldsMean[idx] += unfoldedYields[idx];
unfoldedYieldsSquaredMean[idx] += unfoldedYields[idx]*unfoldedYields[idx];
}
}
}
}
// Final calculation of the mean and RMS for Smearing
TVectorD escaleRandomizedSystRelative(nUnfoldingBins);
if (countEScaleSyst) {
for(int idx = 0; idx < nUnfoldingBins; idx++){
unfoldedYieldsMean[idx] = unfoldedYieldsMean[idx]/double(countEScaleSyst);
unfoldedYieldsSquaredMean[idx] = unfoldedYieldsSquaredMean[idx]/double(countEScaleSyst);
unfoldedYieldsRMS[idx] = sqrt(unfoldedYieldsSquaredMean[idx] -
unfoldedYieldsMean[idx]*unfoldedYieldsMean[idx]);
escaleRandomizedSystRelative[idx] = unfoldedYieldsRMS[idx]/unfoldedYieldsMean[idx];
}
//std::cout << "unfoldedYieldsMean=" << ": "; unfoldedYieldsMean.Print();
//std::cout << "escaleRandomizedSystRelative: "; escaleRandomizedSystRelative.Print();
}
else {
std::cout << "escaleRandomizomized files were not found\n";
}
//
// Calculate error related to the difference between
// data and MC mass distribution shape after all corrections
// had been applied to data and MC. "Residual differences"
//
TVectorD unfoldedYieldsVariation(nUnfoldingBins);
TVectorD escaleResidualDiffSystRelative(nUnfoldingBins);
TString fname = TString("../root_files/yields/") + lumiTag +
TString("/yields_bg-subtracted") + DYTools::analysisTag + TString(".root");
int res=1;
{
TFile file(fname);
if (file.IsOpen()) {
file.Close();
if (readData(fname,observedYields,observedYieldsErr,dummyArr) != 1) {
std::cout << "failed to get data from file <" << fname << ">\n";
throw 2;
}
//
matrixFileName = TString("../root_files/constants/") + lumiTag +
TString("/detResponse_unfolding_constants") + DYTools::analysisTag + TString("_PU.root");
res=applyUnfoldingLocal(observedYields, unfoldedYields, matrixFileName);
if (res==1) usedFiles.push_back(matrixFileName);
//
if (res==1) {
matrixFileName = TString("../root_files/constants/") + lumiTag +
TString("_escale_residual/unfolding_constants") + DYTools::analysisTag +
TString("_escaleResidual.root");
res=applyUnfoldingLocal(observedYields, unfoldedYieldsVariation, matrixFileName);
if (res==1) {
countResidualShape++;
usedFiles.push_back(matrixFileName);
}
}
}
if (res==1) {
for(int idx=0; idx<nUnfoldingBins; idx++){
escaleResidualDiffSystRelative[idx] =
fabs(unfoldedYields[idx] - unfoldedYieldsVariation[idx])
/(unfoldedYields[idx] + unfoldedYieldsVariation[idx]);
}
}
}
//
// Calculate error related to extra smearing function shape
//
std::vector<TString> shapeNames;
shapeNames.push_back("_6binNegs_BreitWigner_20120802");
shapeNames.push_back("_6binNegs_Voigtian_20120802");
std::vector<TVectorD*> unfoldedYieldsShape;
if (1)
for (unsigned int i=0; i<shapeNames.size(); ++i) {
TVectorD observedYieldsShape(nUnfoldingBins);
TVectorD observedYieldsShapeErr(nUnfoldingBins);
TString shapeFName=TString("../root_files/yields/") + lumiTag +
TString("_escale_shape/yields_bg-subtracted") + DYTools::analysisTag +
TString("_") + shapeNames[i] + TString(".root");
TFile fShape(shapeFName);
if (fShape.IsOpen()) {
fShape.Close();
usedFiles.push_back(shapeFName);
if ( readData(shapeFName,observedYieldsShape,observedYieldsShapeErr,dummyArr) !=1) {
std::cout << "failed to load data from <" << shapeFName << ">\n";
throw 2;
}
TString matrixFileNameShape = TString("../root_files/constants/") + lumiTag +
TString("_escale_shape/unfolding_constants") + DYTools::analysisTag +
TString("_") + shapeNames[i] + TString(".root");
TVectorD *shapeYields=new TVectorD(nUnfoldingBins);
{
TFile ftmp(TString("tmp_") + shapeNames[i] + TString(".root"),"recreate");
observedYieldsShape.Write("YieldsSignal");
TVectorD tmp(nUnfoldingBins);
tmp=0;
tmp.Write("YieldsSignalErr");
tmp.Write("YieldsSignalSystErr");
ftmp.Close();
}
res=applyUnfoldingLocal(observedYieldsShape, *shapeYields, matrixFileNameShape);
if (res) {
countFittingShape++;
usedFiles.push_back(matrixFileNameShape);
unfoldedYieldsShape.push_back(shapeYields);
}
else delete shapeYields;
}
}
//
TVectorD escaleFitShapeSystRelative(nUnfoldingBins);
for(int idx=0; idx<nUnfoldingBins; idx++){
double min = unfoldedYields[idx];
double max = unfoldedYields[idx];
for (unsigned int iShape=0; iShape<unfoldedYieldsShape.size(); ++iShape) {
min = TMath::Min( min, (*unfoldedYieldsShape[iShape])[idx] );
max = TMath::Max( max, (*unfoldedYieldsShape[iShape])[idx] );
}
escaleFitShapeSystRelative[idx] = fabs(max-min)/(max+min);
}
//
// Calculate error related to eta binning
//
std::vector<TString> etaBinNames;
etaBinNames.push_back("_2binNegs_Gauss_20120802");
etaBinNames.push_back("_3EB3EENegs_Gauss_20120802");
etaBinNames.push_back("_4binNegs_Gauss_20120802");
etaBinNames.push_back("_4EB3EENegs_Gauss_20120802");
etaBinNames.push_back("_5binNegs_Gauss_20120802");
etaBinNames.push_back("_6binNegs_Gauss_20120802"); // default
etaBinNames.push_back("_6bins_Gauss_20120802");
std::vector<TVectorD*> unfoldedYieldsEta;
unfoldedYieldsEta.reserve(etaBinNames.size());
if (1)
for (unsigned int i=0; i<etaBinNames.size(); ++i) {
TString fEtaFileName=TString("../root_files/yields/") + lumiTag +
TString("_escale_eta/yields_bg-subtracted") + DYTools::analysisTag +
TString("_") + etaBinNames[i] + TString(".root");
TFile fEta(fEtaFileName);
if (fEta.IsOpen()) {
fEta.Close();
usedFiles.push_back(fEtaFileName);
TVectorD observedYieldsEta(nUnfoldingBins);
TVectorD observedYieldsEtaErr(nUnfoldingBins);
if (readData(fEtaFileName,observedYieldsEta,observedYieldsEtaErr,dummyArr)!=1) {
std::cout << "failed to get info from <" << fEtaFileName << ">\n";
throw 2;
}
matrixFileName = TString("../root_files/constants/") + lumiTag +
TString("_escale_eta/unfolding_constants") + DYTools::analysisTag +
TString("_") + etaBinNames[i] + TString(".root");
TVectorD *unfYields = new TVectorD(nUnfoldingBins);
res=applyUnfoldingLocal(observedYieldsEta, *unfYields, matrixFileName);
if (res==1) {
countEtaSyst++;
usedFiles.push_back(matrixFileName);
unfoldedYieldsEta.push_back(unfYields);
}
else {
delete unfYields;
}
}
}
//
TVectorD escaleEtaBinSystRelative(nUnfoldingBins);
for(int idx=0; idx<nUnfoldingBins; idx++){
double min = unfoldedYields[idx];
double max = unfoldedYields[idx];
for (unsigned int iShape=0; iShape<unfoldedYieldsEta.size(); ++iShape) {
min = TMath::Min( min, (*unfoldedYieldsEta[iShape])[idx] );
max = TMath::Max( max, (*unfoldedYieldsEta[iShape])[idx] );
}
escaleEtaBinSystRelative[idx] = fabs(max-min)/(max+min);
}
//
// Put all errors together
//
TVectorD escaleSystPercent(nUnfoldingBins);
for(int idx = 0; idx < nUnfoldingBins; idx++){
escaleSystPercent[idx] = 100.0 *
sqrt(
escaleRandomizedSystRelative[idx]*escaleRandomizedSystRelative[idx]
+ escaleResidualDiffSystRelative[idx]*escaleResidualDiffSystRelative[idx]
+ escaleFitShapeSystRelative[idx]*escaleFitShapeSystRelative[idx]
+ escaleEtaBinSystRelative[idx]*escaleEtaBinSystRelative[idx]
);
}
// Don't write TObject part of the objects
TDescriptiveInfo_t::Class()->IgnoreTObjectStreamer();
TDescriptiveInfo_t *info= new TDescriptiveInfo_t();
std::vector<std::string> *lines = (info) ? (& info->_info) : NULL;
const int bufsize=300;
char buf[bufsize];
std::string sbuf;
snprintf(buf,bufsize," Summary of successful loads:\n");
printf(buf);
if (lines) lines->push_back(buf);
snprintf(buf,bufsize," escale systematics file count= %2d\n", countEScaleSyst);
printf(buf);
if (lines) lines->push_back(buf);
snprintf(buf,bufsize," residual shape syst. file count= %2d\n", countResidualShape);
printf(buf);
if (lines) lines->push_back(buf);
snprintf(buf,bufsize," eta systematics file count= %2d\n", countEtaSyst);
printf(buf);
if (lines) lines->push_back(buf);
snprintf(buf,bufsize," fitting shape file count= %2d\n", countFittingShape);
printf(buf);
if (lines) { lines->push_back(buf); lines->push_back("\n"); }
std::cout << "\n";
int listFilesOnScreen=1;
snprintf(buf,bufsize," Loaded files:\n");
if (listFilesOnScreen) printf(buf);
if (lines) lines->push_back(buf);
for (unsigned int i=0; i<usedFiles.size(); ++i) {
snprintf(buf,bufsize," %s\n",usedFiles[i].Data());
if (listFilesOnScreen) printf(buf);
if (lines) lines->push_back(buf);
}
std::cout << std::endl;
if (saveTexTable) {
std::vector<TString> headers;
std::vector<int> padding;
std::vector<TVectorD*> data;
std::vector<double> factors;
headers.push_back("mass range");
headers.push_back("rapidity range");
headers.push_back("\\multicolumn{1}{c|}{statistical, \\%}"); data.push_back(&escaleRandomizedSystRelative); factors.push_back(100.); padding.push_back(6);
headers.push_back("\\multicolumn{1}{c|}{shape, \\%}"); data.push_back(&escaleFitShapeSystRelative); factors.push_back(100.); padding.push_back(4);
headers.push_back("\\multicolumn{1}{c|}{residual, \\%}"); data.push_back(&escaleResidualDiffSystRelative); factors.push_back(100.); padding.push_back(5);
headers.push_back("\\multicolumn{1}{c|}{$\\eta$ binning, \\%}"); data.push_back(&escaleEtaBinSystRelative); factors.push_back(100.); padding.push_back(6);
headers.push_back("\\multicolumn{1}{c|}{total, \\%}"); data.push_back(&escaleSystPercent); factors.push_back(1.); padding.push_back(3);
TString texFName=TString("../root_files/systematics/") + lumiTag +
TString("/escale_systematics") + DYTools::analysisTag + TString("_tmp.tex");
printTexTable(texFName,headers,padding,data,factors);
}
TString finalFName=TString("../root_files/systematics/") + lumiTag +
TString("/escale_systematics") + DYTools::analysisTag + TString("_tmp.root");
TFile fout(finalFName,"recreate");
unfolding::writeBinningArrays(fout);
escaleRandomizedSystRelative.Write("escaleRandomizedSystRelativeFI");
escaleFitShapeSystRelative.Write("escaleFitShapeSystRelativeFI");
escaleResidualDiffSystRelative.Write("escaleResidualDiffSystRelativeFI");
escaleEtaBinSystRelative.Write("escaleEtaBinSystRelativeFI");
escaleSystPercent.Write("escaleSystPercentFI");
if (info) {
TTree *infoTree = new TTree("Description","description");
infoTree->Branch("description","TDescriptiveInfo_t",&info);
infoTree->Fill();
infoTree->Write();
}
fout.Close();
return;
}
void VoiceActingManager::OnGenerateScript()
{
int i;
char pathname[256];
// stuff data to variables
UpdateData(TRUE);
// prompt to save script
CFileDialog dlg(FALSE, "txt", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "Text files (*.txt)|*.txt||");
if (dlg.DoModal() != IDOK)
return;
string_copy(pathname, dlg.GetPathName(), 256);
fp = cfopen(pathname, "wt", CFILE_NORMAL);
if (!fp)
{
MessageBox("Can't open file to save.", "Error!");
return;
}
fout("%s\n", Mission_filename);
fout("%s\n\n", The_mission.name);
if (m_export_everything || m_export_command_briefings)
{
fout("\n\nCommand Briefings\n-----------------\n\n");
for (i = 0; i < Cmd_briefs[0].num_stages; i++)
{
CString entry = m_script_entry_format;
entry.Replace("\r\n", "\n");
cmd_brief_stage *stage = &Cmd_briefs[0].stage[i];
entry.Replace("$filename", stage->wave_filename);
entry.Replace("$message", stage->text);
entry.Replace("$persona", "<no persona specified>");
entry.Replace("$sender", "<no sender specified>");
fout("%s\n\n\n", (char *) (LPCTSTR) entry);
}
}
if (m_export_everything || m_export_briefings)
{
fout("\n\nBriefings\n---------\n\n");
for (i = 0; i < Briefings[0].num_stages; i++)
{
CString entry = m_script_entry_format;
entry.Replace("\r\n", "\n");
brief_stage *stage = &Briefings[0].stages[i];
entry.Replace("$filename", stage->voice);
entry.Replace("$message", stage->new_text);
entry.Replace("$persona", "<no persona specified>");
entry.Replace("$sender", "<no sender specified>");
fout("%s\n\n\n", (char *) (LPCTSTR) entry);
}
}
if (m_export_everything || m_export_debriefings)
{
fout("\n\nDebriefings\n-----------\n\n");
for (i = 0; i < Debriefings[0].num_stages; i++)
{
CString entry = m_script_entry_format;
entry.Replace("\r\n", "\n");
debrief_stage *stage = &Debriefings[0].stages[i];
entry.Replace("$filename", stage->voice);
entry.Replace("$message", stage->new_text);
entry.Replace("$persona", "<no persona specified>");
entry.Replace("$sender", "<no sender specified>");
fout("%s\n\n\n", (char *) (LPCTSTR) entry);
}
}
if (m_export_everything || m_export_messages)
{
fout("\n\nMessages\n--------\n\n");
for (i = 0; i < Num_messages - Num_builtin_messages; i++)
{
CString entry = m_script_entry_format;
entry.Replace("\r\n", "\n");
MMessage *message = &Messages[i + Num_builtin_messages];
entry.Replace("$filename", message->wave_info.name);
entry.Replace("$message", message->message);
if (message->persona_index >= 0)
entry.Replace("$persona", Personas[message->persona_index].name);
else
entry.Replace("$persona", "<none>");
entry.Replace("$sender", get_message_sender(message->name));
fout("%s\n\n\n", (char *) (LPCTSTR) entry);
}
}
cfclose(fp);
// notify
MessageBox("Script generation complete.", "Woohoo!");
}
bool MomentumEstimator::putSpecial(xmlNodePtr cur, ParticleSet& elns, bool rootNode)
{
OhmmsAttributeSet pAttrib;
string hdf5_flag="yes";
pAttrib.add(hdf5_flag,"hdf5");
pAttrib.add(M,"samples");
pAttrib.put(cur);
hdf5_out = (hdf5_flag=="yes");
xmlNodePtr kids=cur->children;
while (kids!=NULL)
{
string cname((const char*)(kids->name));
if (cname=="kpoints")
{
string ctype("manual");
OhmmsAttributeSet pAttrib;
pAttrib.add(ctype,"mode");
pAttrib.add(kgrid,"grid");
pAttrib.put(kids);
int numqtwists(6*kgrid+3);
std::vector<int> qk(0);
mappedQtonofK.resize(numqtwists,qk);
compQ.resize(numqtwists);
RealType qn(4.0*M_PI*M_PI*std::pow(Lattice.Volume,-2.0/3.0));
mappedQnorms.resize(numqtwists,qn*0.5/RealType(M));
if (twist[0]==0) mappedQnorms[kgrid]=qn/RealType(M);
if (twist[1]==0) mappedQnorms[3*kgrid+1]=qn/RealType(M);
if (twist[2]==0) mappedQnorms[5*kgrid+2]=qn/RealType(M);
// app_log()<<" Jnorm="<<qn<<endl;
Q.resize(numqtwists);
for (int i=-kgrid; i<(kgrid+1); i++)
{
PosType kpt;
kpt[0]=i-twist[0];
kpt[1]=i-twist[1];
kpt[2]=i-twist[2];
kpt=Lattice.k_cart(kpt);
Q[i+kgrid]=abs(kpt[0]);
Q[i+kgrid+(2*kgrid+1)]=abs(kpt[1]);
Q[i+kgrid+(4*kgrid+2)]=abs(kpt[2]);
}
app_log()<<" Using all k-space points with (nx^2+ny^2+nz^2)^0.5 < "<< kgrid <<" for Momentum Distribution."<<endl;
app_log()<<" My twist is:"<<twist[0]<<" "<<twist[1]<<" "<<twist[2]<<endl;
int indx(0);
for (int i=-kgrid; i<(kgrid+1); i++)
{
for (int j=-kgrid; j<(kgrid+1); j++)
{
for (int k=-kgrid; k<(kgrid+1); k++)
{
if (std::sqrt(i*i+j*j+k*k)<=kgrid)
{
PosType kpt;
kpt[0]=i-twist[0];
kpt[1]=j-twist[1];
kpt[2]=k-twist[2];
//convert to Cartesian: note that 2Pi is multiplied
kpt=Lattice.k_cart(kpt);
kPoints.push_back(kpt);
mappedQtonofK[i+kgrid].push_back(indx);
mappedQtonofK[j+kgrid+(2*kgrid+1)].push_back(indx);
mappedQtonofK[k+kgrid+(4*kgrid+2)].push_back(indx);
indx++;
}
}
}
}
}
kids=kids->next;
}
if (rootNode)
{
std::stringstream sstr;
int t0=(int)round(100.0*twist[0]);
int t1=(int)round(100.0*twist[1]);
int t2=(int)round(100.0*twist[2]);
sstr<<"Kpoints."<<t0<<"_"<<t1<<"_"<<t2<<".dat";
ofstream fout(sstr.str().c_str());
fout.setf(ios::scientific, ios::floatfield);
fout << "# mag_k kx ky kz " << endl;
for (int i=0; i<kPoints.size(); i++)
{
float khere(std::sqrt(dot(kPoints[i],kPoints[i])));
fout<<khere<<" "<<kPoints[i][0]<<" "<<kPoints[i][1]<<" "<<kPoints[i][2]
<<endl;
}
fout.close();
sstr.str("");
sstr<<"Qpoints."<<t0<<"_"<<t1<<"_"<<t2<<".dat";
ofstream qout(sstr.str().c_str());
qout.setf(ios::scientific, ios::floatfield);
qout << "# mag_q" << endl;
for (int i=0; i<Q.size(); i++)
{
qout<<Q[i]<<endl;
}
qout.close();
}
nofK.resize(kPoints.size());
norm_nofK=1.0/RealType(M);
return true;
}
bool save_zoltan_hypergraph_structure(const std::string& filename,
const graphlab::local_graph<VertexType, EdgeType>& graph) {
typedef graphlab::local_graph<VertexType, EdgeType> graph_type;
typedef typename graph_type::edge_type edge_type;
typedef typename graph_type::edge_list_type edge_list_type;
std::ofstream fout(filename.c_str());
if(!fout.good()) return false;
// ok. I need to uniquely number each edge.
// how?
boost::unordered_map<std::pair<vertex_id_type,
vertex_id_type>, size_t> edgetoid;
size_t curid = 0;
for(vertex_id_type i = 0; i < graph.num_vertices(); ++i) {
foreach(const typename graph_type::edge_type& edge, graph.in_edges(i)) {
std::pair<vertex_id_type, vertex_id_type> e =
std::make_pair(edge.source(), edge.target());
if (e.first > e.second) std::swap(e.first, e.second);
if (edgetoid.find(e) == edgetoid.end()) {
edgetoid[e] = curid;
++curid;
}
}
foreach(const typename graph_type::edge_type& edge, graph.out_edges(i)) {
std::pair<vertex_id_type, vertex_id_type> e =
std::make_pair(edge.source(), edge.target());
if (e.first > e.second) std::swap(e.first, e.second);
if (edgetoid.find(e) == edgetoid.end()) {
edgetoid[e] = curid;
++curid;
}
}
}
size_t numedges = curid;
// each edge is a vertex, each vertex is an edge
// a pin is total adjacency of a hyper edge
fout << numedges << "\n\n";
for (size_t i = 0;i < numedges; ++i) {
fout << i+1 << "\n";
}
fout << "\n";
fout << graph.num_vertices() << "\n\n";
fout << numedges * 2 << "\n\n";
// loop over the "hyperedge" and write out the edges it is adjacent to
for(vertex_id_type i = 0; i < graph.num_vertices(); ++i) {
boost::unordered_set<size_t> adjedges;
foreach(const typename graph_type::edge_type& edge, graph.in_edges(i)) {
std::pair<vertex_id_type, vertex_id_type> e =
std::make_pair(edge.source(), edge.target());
if (e.first > e.second) std::swap(e.first, e.second);
adjedges.insert(edgetoid[e]);
}
foreach(const typename graph_type::edge_type& edge, graph.out_edges(i)) {
std::pair<vertex_id_type, vertex_id_type> e =
std::make_pair(edge.source(), edge.target());
if (e.first > e.second) std::swap(e.first, e.second);
adjedges.insert(edgetoid[e]);
}
// write
std::vector<size_t> adjedgesvec;
std::copy(adjedges.begin(), adjedges.end(),
std::inserter(adjedgesvec, adjedgesvec.end()));
fout << i+1 << " " << adjedgesvec.size() << "\t";
for (size_t j = 0;j < adjedgesvec.size(); ++j) {
fout << adjedgesvec[j] + 1;
if (j < adjedgesvec.size() - 1) fout << "\t";
}
fout << "\n";
}
fout.close();
return true;
} // end of save_zoltan_hypergraph_structure
int main(int argc, char * argv[])
{
XMLNode xMainNode = XMLNode::openFileHelper(argv[1], "score-partwise");
std::string filename = (std::string) argv[2];
std::ofstream fout(filename);
int n_measures = std::stoi(argv[3]);
// note_count records relative frequency of each pitch bar-by-bar
// notes related by octaves considered equivalent
// C natural is 0
// each half step increments by 1
// quarter note has weight 1
double note_count[n_measures][12];
for(int i=0; i< 12; i++){
for(int j = 0; j < n_measures;j++)
{
note_count[j][i]=0;
}
}
//count bars starting from 0
int num_notes;
int num_parts = xMainNode.nChildNode("part");
int k =0;
// if score is written with multiple parts, loop over parts
while(k < num_parts){
XMLNode partNode = xMainNode.getChildNode("part", k);
for(int current_meas = 0; current_meas < n_measures; current_meas++)
{
XMLNode mNode = partNode.getChildNode("measure",current_meas);
XMLNode attNode = mNode.getChildNode("attributes");
XMLNode dNode;
if(!attNode.isEmpty())
dNode = attNode.getChildNode("divisions");
// divisions counts number of sub-beats in each beat
double divisions;
if(!dNode.isEmpty())
{
// is there a better way to read from xmlParser
// than reading strings first and converting to numbers?
std::string st = (std::string) dNode.getText();
// note we use double because we want to do division later
divisions = std::stof(st);
}
num_notes = mNode.nChildNode("note");
//loop over notes
for(int i = 0; i < num_notes; i++)
{
XMLNode nNode = mNode.getChildNode("note",i);
XMLNode pitchNode = nNode.getChildNode("pitch");
// ignores grace notes (for now)
if(!pitchNode.isEmpty() && nNode.getChildNode("grace").isEmpty())
{
// XML records notes by letter
char ch = *(pitchNode.getChildNode("step").getText());
// convert letter to number
int note_val = note_to_int(ch);
// take accidentals into account
XMLNode aNode = pitchNode.getChildNode("alter");
if(!aNode.isEmpty()){
std::string alt_str = (std::string) aNode.getText();
note_val += std::stoi(alt_str);
note_val %= 12;
}
XMLNode durNode = nNode.getChildNode("duration");
std::string dur_str = (std::string) durNode.getText();
double duration = std::stof(dur_str)/divisions;
note_count[current_meas][note_val] += duration;
}
}
}
k++;
}
for(int j = 0;j < n_measures; j++)
{
for(int i = 0; i < 12; i++){
if(note_count[j][i] < 0.0001)
note_count[j][i] = 0;
fout <<note_count[j][i] << " \t";
}
fout << std::endl;
}
fout.close();
return 0;
}
/**
* \brief Conversion function
* \param[in] chInputFile Input file name to convert from
* \param[in] chOutputFile Output file name to convert to
* \return Result code
*
* This is the actual conversion function with input and output file name.
*/
HRESULT CBlfLogConverter::ConvertFile(string& chInputFile, string& chOutputFile)
{
HRESULT hResult = S_OK;
try
{
bool isOk = true;
// Create BLF Library interface
BLF::IBlfLibrary* pBlfLib = BLF::GetIBlfLibrary();
isOk = (NULL != pBlfLib);
if (!isOk)
{
m_omstrConversionStatus = _("Unable to get BLF Library interface");
m_hResult = ERR_UNABLE_TO_GET_LIB_INTERFACE;
return ERR_UNABLE_TO_GET_LIB_INTERFACE;
}
// Load BLF file
CBlfLibraryKeeper blfKeeper(pBlfLib);
HRESULT hResult = pBlfLib->Load(chInputFile);
if (hResult != S_OK)
{
m_omstrConversionStatus = _("Error: Invalid BLF file");
m_hResult = hResult;
return hResult;
}
std::ofstream fout(chOutputFile.c_str());
// Let the output stream to throw exception on errors
fout.exceptions(std::ifstream::failbit | std::ifstream::badbit);
if (!fout.is_open())
{
m_omstrConversionStatus = _("Output File path is not found");
m_hResult = ERR_OUTPUT_FILE_NOTFOUND;
return ERR_OUTPUT_FILE_NOTFOUND;
}
HRESULT hRes = WriteToLog(pBlfLib, fout);
if (!SUCCEEDED(hRes))
{
if(hRes == ERR_PROTOCOL_NOT_SUPPORTED)
{
m_omstrConversionStatus = _("Error: No CAN data found for conversion.");
m_hResult = ERR_PROTOCOL_NOT_SUPPORTED;
return ERR_PROTOCOL_NOT_SUPPORTED;
}
else
{
m_omstrConversionStatus = _("Error: Unable to convert file.");
m_hResult = ERR_OUTPUT_FILE_NOTFOUND;
return ERR_OUTPUT_FILE_NOTFOUND;
}
}
}
catch (std::ifstream::failure& e)
{
// Process output stream errors (like not enough disk space)
m_omstrConversionStatus = _("Error while writing output file.");
m_hResult = E_FAIL;
return E_FAIL;
}
catch (const std::exception& e)
{
// Process critical error
m_omstrConversionStatus = e.what();
m_hResult = E_FAIL;
return E_FAIL;
}
m_omstrConversionStatus = _("Conversion Completed Successfully");
m_hResult = hResult;
return hResult;
}
void user_settings_io::export_settings(const std::string& output_dir)
{
if(!settings_file_name_.empty())
{
namespace fs = boost::filesystem;
std::string config_dir = output_dir + "/config";
fs::path out_path(config_dir);
fs::create_directory(out_path);
YAML::Emitter out;
out << YAML::BeginMap;
out << YAML::Key << usc::fs;
out << YAML::Value << settings_.get_fs();
out << YAML::Key << usc::forces_dynamic;
out << YAML::Value << settings_.get_forces_dynamic();
out << YAML::Key << usc::excitation_time_step;
out << YAML::Value << settings_.get_excitation_time_step();
out << YAML::Key << usc::excitation_time;
out << YAML::Value << settings_.get_excitation_time();
out << YAML::Key << usc::rtss::self;
out << YAML::BeginMap;
out << YAML::Key << usc::rtss::initial_step;
out << YAML::Value << settings_.get_relaxation_time_step_spec().initial_step;
out << YAML::Key << usc::rtss::time_delta;
out << YAML::Value << settings_.get_relaxation_time_step_spec().time_delta;
out << YAML::Key << usc::rtss::coefficient;
out << YAML::Value << settings_.get_relaxation_time_step_spec().coefficient;
out << YAML::EndMap;
out << YAML::Key << usc::simulations_count;
out << YAML::Value << settings_.get_simulations_count();
out << YAML::Key << usc::visualization_nodes;
out << YAML::Value << YAML::BeginSeq;
const auto& vis_nodes = settings_.get_visualization_nodes();
for(auto it = vis_nodes.begin(); it != vis_nodes.end(); ++it)
{
out << *it;
}
out << YAML::EndSeq;
if(!settings_.get_force_application_nodes().empty())
{
out << YAML::Key << usc::force_application_nodes;
out << YAML::Value << YAML::BeginSeq;
const auto& force_nodes = settings_.get_force_application_nodes();
for(auto it = force_nodes.begin(); it != force_nodes.end(); ++it)
{
out << *it;
}
out << YAML::EndSeq;
}
if(settings_.get_cutoff_distance())
{
out << YAML::Key << usc::l0;
out << YAML::Value << *settings_.get_cutoff_distance();
}
if(!settings_.get_network_file_path())
{
if(settings_.get_node_positions())
{
out << YAML::Key << usc::nodes;
const node_positions_type& node_positions = *settings_.get_node_positions();
out << YAML::Value << YAML::BeginSeq;
for(auto it = node_positions.begin(); it != node_positions.end(); ++it)
{
out << YAML::BeginSeq;
out << (*it)[0];
out << (*it)[1];
out << (*it)[2];
out << YAML::EndSeq;
}
out << YAML::EndSeq;
}
if(settings_.get_links())
{
out << YAML::Key << usc::links;
out << YAML::Value << YAML::BeginSeq;
const std::vector<std::pair<std::size_t, std::size_t>>& links = *settings_.get_links();
for(auto it = links.begin(); it != links.end(); ++it)
{
out << YAML::BeginSeq << it->first << it->second << YAML::EndSeq;
}
out << YAML::EndSeq;
}
}
else
{
out << YAML::Key << usc::network_file_path;
/**
* @note Output only network file name as it will anyway be copied to the same directory as user config.
*/
std::string file_name = *settings_.get_network_file_path();
if(std::string::npos != file_name.find_first_of('/'))
{
file_name = file_name.substr(file_name.find_last_of('/')+1);
}
out << YAML::Value << file_name;
}
out << YAML::EndMap;
std::ofstream fout(config_dir + "/config.yaml");
if(!fout.is_open())
{
LOG(logger::error, "Cannot create output config file.");
return;
}
fout << out.c_str() << std::endl;
fout.close();
if(settings_.get_network_file_path())
{
utils::copy_file(*settings_.get_network_file_path(), config_dir);
}
}
}
int main(int argc, char **argv)
{
// run for selected COCO functions
for(uint function = 1; function < 25; function++) {
// read XML config
std::ifstream fin(argv[1]);
if (!fin) {
throw std::string("Error opening file! ");
}
std::string xmlFile, temp;
while (!fin.eof()) {
getline(fin, temp);
xmlFile += "\n" + temp;
}
fin.close();
// set log and stats parameters
std::string funcName = uint2str(function);
std::string logName = "log", statsName = "stats";
if(function < 10) {
logName += "0";
statsName += "0";
}
logName += uint2str(function) + ".txt";
statsName += uint2str(function) + ".txt";
// update in XML
XMLResults results;
XMLNode xConfig = XMLNode::parseString(xmlFile.c_str(), "ECF", &results);
XMLNode registry = xConfig.getChildNode("Registry");
XMLNode func = registry.getChildNodeWithAttribute("Entry", "key", "coco.function");
func.updateText(funcName.c_str());
XMLNode log = registry.getChildNodeWithAttribute("Entry", "key", "log.filename");
log.updateText(logName.c_str());
XMLNode stats = registry.getChildNodeWithAttribute("Entry", "key", "batch.statsfile");
stats.updateText(statsName.c_str());
// write back
std::ofstream fout(argv[1]);
fout << xConfig.createXMLString(true);
fout.close();
// finally, run ECF on single function
StateP state (new State);
//set newAlg
MyAlgP alg = (MyAlgP) new MyAlg;
state->addAlgorithm(alg);
// set the evaluation operator
state->setEvalOp(new FunctionMinEvalOp);
state->initialize(argc, argv);
state->run();
}
return 0;
}
// print the yields
void CreateCrossSectionTable
(
const std::string& label,
const std::string& hist_name = "h_reco_full_yield",
const std::string& output_file = "",
bool print_latex = false
)
{
const double lumi = 0.082; // fb^-1
// map of samples and yields
const dy::YieldVector yields = dy::GetYieldVector(label, hist_name);
const dy::Yield y_data = yields[dy::Sample::data];
const dy::Yield y_bk_pred = dy::GetBackgroundPred(label, hist_name);
const dy::Yield y_dy_pred = yields[dy::Sample::dyll];
const dy::Yield y_mc_pred = y_dy_pred + y_bk_pred;
const dy::Yield y_den_acc = dy::GetYieldFromLabel(dy::Sample::dyll, label, "h_acc_gen_den");
const dy::Yield y_num_acc = dy::GetYieldFromLabel(dy::Sample::dyll, label, "h_acc_rec_num");
const dy::Yield y_acc = dy::GetYieldFromLabel(dy::Sample::dyll, label, "h_acc_rec");
const dy::Yield y_nsig = y_data - y_bk_pred;
// xsec = (Nobs - Nbkg)/(lumi * acc)
dy::Yield xsec = y_nsig/(lumi * y_acc);
xsec = xsec * (1e-6); // fb --> nb
std::string result;
if (print_latex)
{
string latex("\\begin{table}[ht!]\n" );
latex.append("\\begin{center}\n" );
latex.append("\\begin{tabular}{l|ccc} \\hline\\hline\n" );
latex.append("source & $ee$ & $\\mu\\mu$ \\\\\n" );
latex.append("\\hline\n" );
latex.append(Form("%s \\\\\n", GetLatex("$N_{obs}$" , y_data).c_str()));
latex.append(Form("%s \\\\\n", GetLatex("$N_{mc}$" , y_mc_pred).c_str()));
latex.append(Form("%s \\\\\n", GetLatex("$N_{dyll}$", y_dy_pred).c_str()));
latex.append(Form("%s \\\\\n", GetLatex("$N_{bkgd}$", y_bk_pred).c_str()));
latex.append(Form("%s \\\\\n", GetLatex("$N_{sig}$" , y_nsig).c_str()));
latex.append(Form("%s \\\\\n", GetLatex("Acc" , y_acc).c_str()));
latex.append("\\hline\\hline\n");
latex.append(Form("%s \\\\\n", GetLatex("Sigma (nb)", xsec).c_str()));
latex.append("\\hline\\hline\n" );
latex.append("\\end{tabular}\n" );
latex.append("\\caption{Drell-Yan Exercise Cross-Section}\n" );
latex.append("\\end{center}\n" );
latex.append("\\end{table}" );
result = latex;
}
else
{
// make the table
CTable t_yields;
t_yields.useTitle();
t_yields.setTitle("Cross-Sectoin for Drell-Yan Exercise");
t_yields.setTable()
( "ee", "mm")
("N_obs" , y_data.ee.pm("4.0"), y_data.mm.pm("4.0"))
("N_mc" , y_mc_pred.ee.pm("4.1"), y_mc_pred.mm.pm("4.1"))
("N_dyll" , y_dy_pred.ee.pm("4.1"), y_dy_pred.mm.pm("4.1"))
("N_bkgd" , y_bk_pred.ee.pm("4.1"), y_bk_pred.mm.pm("4.1"))
("N_sig" , y_nsig.ee.pm("4.1"), y_nsig.mm.pm("4.1"))
("Num Acc" , y_num_acc.ee.pm("4.3"), y_num_acc.mm.pm("4.3"))
("Den Acc" , y_den_acc.ee.pm("4.3"), y_den_acc.mm.pm("4.3"))
("Acc" , y_acc.ee.pm("4.3"), y_acc.mm.pm("4.3"))
("Sigma (nb)" , xsec.ee.pm("4.3"), xsec.mm.pm("4.3"))
;
// print it
std::ostringstream os;
os << t_yields;
result = os.str();
}
// output
if (output_file.empty())
{
std::cout << result << std::endl;
}
else
{
std::ofstream fout(output_file);
fout << result << std::endl;
}
}
bool MSD::ProcessLine()
{
cerr << "MSD reordering Step1: generating msd.reordering.model.1" << endl;
ifstream finsrc(m_src);
ifstream fintgt(m_tgt);
ifstream finaln(m_aln);
string srcline, tgtline, alnline;
//check validity of input files
if (!finsrc){
cerr << "Please check source file: " << m_src << endl;
return false;
}
if (!fintgt){
cerr << "Please check target file: " << m_tgt << endl;
return false;
}
if (!finaln){
cerr << "Please check alignment file: " << m_aln << endl;
return false;
}
ofstream fout(m_tmpModel);
if (!fout){
cerr << "Couldn't create output file msd.reordering.model.1"
<< endl;
}
//start whole process
int lineNo = 1;
while (getline(finsrc, srcline)
&& getline(fintgt, tgtline)
&& getline(finaln, alnline)){
if (lineNo % 10000 == 0){
cerr << "Processed " << lineNo << " lines." << endl;
}
SentnInfo srcsen, tgtsen;
srcsen.m_words = BasicMethod::Split(srcline);
tgtsen.m_words = BasicMethod::Split(tgtline);
srcsen.m_align.assign(srcsen.m_words.size(), vector<size_t>());
tgtsen.m_align.assign(tgtsen.m_words.size(), vector<size_t>());
srcsen.m_alnmax.assign(srcsen.m_words.size(), -1);
tgtsen.m_alnmax.assign(tgtsen.m_words.size(), -1);
srcsen.m_alnmin.assign(srcsen.m_words.size(), -1);
tgtsen.m_alnmin.assign(tgtsen.m_words.size(), -1);
tgtsen.m_ppstart.assign(tgtsen.m_words.size(), vector<MSDPhrasePair*>());
tgtsen.m_ppend.assign(tgtsen.m_words.size(), vector<MSDPhrasePair*>());
for (auto& align : BasicMethod::Split(alnline))
{
unsigned int srcWordId, tgtWordId;
//check aligment format
if (!sscanf_s(align.c_str(), "%d-%d", &srcWordId, &tgtWordId)){
cerr << "WARNING: " << align << " is a bad aligment point in sentence " << endl
<< "T: " << tgtline << endl << "S: " << srcline << endl;
}
//check out of bound case
if ((size_t)srcWordId >= srcsen.m_words.size() || (size_t)tgtWordId >= tgtsen.m_words.size()){
cerr << "WARNING: " << align << " out of bounds." << endl
<< "T: " << tgtline << endl << "S: " << srcline << endl;
}
srcsen.m_align[srcWordId].push_back(tgtWordId);
tgtsen.m_align[tgtWordId].push_back(srcWordId);
if (srcsen.m_alnmax[srcWordId] == -1){
srcsen.m_alnmax[srcWordId] = tgtWordId;
}
else{
if (tgtWordId > srcsen.m_alnmax[srcWordId]){
srcsen.m_alnmax[srcWordId] = tgtWordId;
}
}
if (tgtsen.m_alnmax[tgtWordId] == -1){
tgtsen.m_alnmax[tgtWordId] = srcWordId;
}
else{
if (srcWordId > tgtsen.m_alnmax[tgtWordId]){
tgtsen.m_alnmax[tgtWordId] = srcWordId;
}
}
if (srcsen.m_alnmin[srcWordId] == -1){
srcsen.m_alnmin[srcWordId] = tgtWordId;
}
else{
if (tgtWordId < srcsen.m_alnmin[srcWordId]){
srcsen.m_alnmin[srcWordId] = tgtWordId;
}
}
if (tgtsen.m_alnmin[tgtWordId] == -1){
tgtsen.m_alnmin[tgtWordId] = srcWordId;
}
else{
if (srcWordId < tgtsen.m_alnmin[tgtWordId]){
tgtsen.m_alnmin[tgtWordId] = srcWordId;
}
}
srcsen.m_align[srcWordId].push_back(tgtWordId);
tgtsen.m_align[tgtWordId].push_back(srcWordId);
}
ExtractPhrasePairs(srcsen, tgtsen);
CalculateMSD(srcsen, tgtsen);
OutputMSDtemp(tgtsen, fout);
lineNo++;
}
fout.close();
finsrc.close();
fintgt.close();
finaln.close();
}
void bfcread_tagsBranch(
const char *MainFile="/afs/rhic.bnl.gov/star/data/samples/gstar.tags.root",
Int_t printEvent=1,
const char *fname="qa_tags.out",
Int_t fullPrint=0)
{
// start timer
TStopwatch timer;
timer.Start();
cout << endl << endl;
cout << " bfcread_tagsBranch.C: input file = " << MainFile << endl;
cout << " bfcread_tagsBranch.C: print event # " << printEvent << endl;
cout << " bfcread_tagsBranch.C: output file = " << fname << endl;
cout << " bfcread_tagsBranch.C: full printout = " << fullPrint << endl;
cout << endl;
ofstream fout(fname);
fout << endl << endl;
fout << " bfcread_tagsBranch.C: input file = " << MainFile << endl;
fout << " bfcread_tagsBranch.C: print evt# = " << printEvent << endl;
fout << " bfcread_tagsBranch.C: output file = " << fname << endl;
fout << " bfcread_tagsBranch.C: full printout = " << fullPrint << endl;
fout << endl;
TFile *file = TFile::Open(MainFile);
TTree *tree = (TTree*)file->Get("Tag");
cout <<" read file: " << file->GetName() << endl << endl;
Int_t nEntries = tree->GetEntries();
cout << " Total # events = " << nEntries << endl;
TObjArray *leaves = tree->GetListOfLeaves();
Int_t nLeaves = leaves->GetEntriesFast();
cout << " Total # leaves = " << nLeaves << endl;
TString *tName = new TString(" ");
TNamed *tableName=0;
TObjArray *tagTable = new TObjArray;
Int_t tableCount = 0;
Int_t *tableIndex = new Int_t[nLeaves];
Int_t tagCount = 0;
TBranch *branch=0;
TLeaf *leaf=0;
Int_t ndim =0;
//count number of tag tables encoded in the TTree branch names
for (Int_t l=0;l<nLeaves;l++) {
leaf = (TLeaf*)leaves->UncheckedAt(l);
tagCount+=leaf->GetNdata();
branch = leaf->GetBranch();
cout << "leaf # " << l << " br name = " <<
branch->GetName() << endl;
//new tag table name
if ( strstr(branch->GetName(), tName->Data()) == 0 ) {
tName = new TString(branch->GetName());
tName->Resize(tName->Index("."));
//the tableName is encoded in the branch Name before the "."
tableName = new TNamed(tName->Data(),"Tag");
tagTable->AddLast(tableName);
tableCount++;
}
tableIndex[l]=tableCount-1;
}
cout << endl << " Total num tables(branches),tags = "
<< tableCount << " " << tagCount << endl << endl;
Int_t *countTagsTable = new Int_t[tableCount];
Int_t *countLeavesTable = new Int_t[tableCount];
Float_t *sumTagsLeaf = new Float_t[nLeaves];
Int_t *countTagsLeaf = new Int_t[nLeaves];
// Now loop over leaves (to get values of tags)
Int_t setBranch = -1;
Int_t nowBranch = -1;
for (Int_t l=0;l<nLeaves;l++) {
leaf = (TLeaf*)leaves->UncheckedAt(l);
branch = leaf->GetBranch();
ndim = leaf->GetNdata();
nowBranch = tableIndex[l];
//cout << " nowbranch, setBranch = " <<
// nowBranch << ", "<< setBranch << endl;
Float_t RtableIndex=tableIndex[l];
if (nowBranch != setBranch){
setBranch=nowBranch;
cout << " QAInfo: branch ";
cout.width(2);
cout << tableIndex[l] << " = ";
cout.width(10);
cout << ((TNamed*)tagTable->UncheckedAt(tableIndex[l]))->GetName();
cout << endl;
fout << " QAInfo: branch ";
fout.width(2);
fout << RtableIndex << " = ";
fout.width(10);
fout << ((TNamed*)tagTable->UncheckedAt(tableIndex[l]))->GetName();
fout << endl;
}
countTagsTable[tableIndex[l]]+=leaf->GetNdata();
countLeavesTable[tableIndex[l]]++;
countTagsLeaf[l]+=ndim;
Float_t Rl=l;
Float_t Rndim=ndim;
cout << " QAInfo: leaf ";
cout.width(3);
cout << l << " has ";
cout.width(1);
cout << ndim << " tags:";
cout << endl;
fout << " QAInfo: leaf ";
fout.width(3);
fout << Rl << " has ";
fout.width(1);
fout << Rndim << " tags:";
fout << endl;
// loop over all events in each leaf
for (Int_t nev=0; nev<nEntries; nev++) {
branch->GetEntry(nev);
// loop over all tags in each leaf for each event
for (Int_t itag=0;itag<ndim;itag++) {
Int_t ik = nev+1;
if (ik==printEvent) {
cout << " QAInfo: " << leaf->GetName();
if (ndim>1) cout << '['<<itag<<']';
cout << " = " << leaf->GetValue(itag) << endl;
fout << " QAInfo: " << leaf->GetName();
if (ndim>1) fout << '['<<itag<<']';
fout << " = " << leaf->GetValue(itag) << endl;
}
sumTagsLeaf[l]+=leaf->GetValue(itag);
}
}
}
cout << endl << endl;
fout << endl << endl;
if (fullPrint == 1){
// loop over leaves again for printout at end
for (Int_t m=0; m<nLeaves; m++){
leaf = (TLeaf*)leaves->UncheckedAt(m);
branch = leaf->GetBranch();
ndim = leaf->GetNdata();
cout << " QAInfo: branch ";
cout.width(2);
cout << tableIndex[m] << " = ";
cout.width(10);
cout << ((TNamed*)tagTable->UncheckedAt(tableIndex[m]))->GetName();
cout << ", leaf ";
cout.width(3);
cout << m << " = ";
cout.width(24);
cout << leaf->GetName();
cout << ", #tags = ";
cout.width(1);
cout << ndim;
cout << endl;
Float_t RtableIndex=tableIndex[m];
Float_t Rm=m;
Float_t Rndim=ndim;
fout << " QAInfo: branch ";
fout.width(2);
fout << RtableIndex << " = ";
fout.width(10);
fout << ((TNamed*)tagTable->UncheckedAt(tableIndex[m]))->GetName();
fout << ", leaf ";
fout.width(3);
fout << Rm << " = ";
fout.width(24);
fout << leaf->GetName();
fout << ", #tags = ";
fout.width(1);
fout << Rndim;
fout << endl;
}
}
cout << endl << endl;
fout << endl << endl;
// loop over leaves again for printout at end of averages
cout << " QAInfo: each leaf's avg over all tags,evts: " << endl;
fout << " QAInfo: each leaf's avg over all tags,evts: " << endl;
for (Int_t m=0; m<nLeaves; m++){
leaf = (TLeaf*)leaves->UncheckedAt(m);
sumTagsLeaf[m]/=countTagsLeaf[m]*nEntries;
cout << " QAInfo: avg leaf #";
cout.width(2);
cout << m << ", ";
cout.width(23);
cout << leaf->GetName() << " = ";
cout.width(12);
cout << sumTagsLeaf[m];
cout << endl;
Float_t Rm=m;
fout << " QAInfo: avg leaf #";
fout.width(2);
fout << Rm << ", ";
fout.width(23);
fout << leaf->GetName() << " = ";
fout.width(12);
fout << sumTagsLeaf[m];
fout << endl;
}
cout << endl << endl;
fout << endl << endl;
// loop over all tables
for (Int_t m=0; m<tableCount; m++){
cout << " QAInfo: branch(table) ";
cout.width(10);
cout << ((TNamed*)tagTable->UncheckedAt(m))->GetName() << " has ";
cout.width(4);
cout << countLeavesTable[m] << " leaves,";
cout.width(4);
cout << countTagsTable[m] << " tags" << endl;
Float_t RcountLeavesTable=countLeavesTable[m];
Float_t RcountTagsTable=countTagsTable[m];
fout << " QAInfo: branch(table) ";
fout.width(10);
fout << ((TNamed*)tagTable->UncheckedAt(m))->GetName() << " has ";
fout.width(4);
fout << RcountLeavesTable << " leaves,";
fout.width(4);
fout << RcountTagsTable << " tags" << endl;
}
cout << endl << endl;
fout << endl << endl;
Float_t RnEntries=nEntries;
Float_t RtableCount=tableCount;
Float_t RnLeaves=nLeaves;
Float_t RtagCount=tagCount;
cout << " QAInfo: tot num events = " << nEntries << endl;
fout << " QAInfo: tot num events = " << RnEntries << endl;
cout << " QAInfo: tot num branches = " << tableCount << endl;
fout << " QAInfo: tot num branches = " << RtableCount << endl;
cout << " QAInfo: tot num leaves = " << nLeaves << endl;
fout << " QAInfo: tot num leaves = " << RnLeaves << endl;
cout << " QAInfo: tot num tags = " << tagCount << endl;
fout << " QAInfo: tot num tags = " << RtagCount << endl;
// stop timer and print results
timer.Stop();
cout<< endl << endl <<"RealTime="<<timer.RealTime()<<
" seconds, CpuTime="<<timer.CpuTime()<<" seconds"<<endl;
//cleanup
file->Close();
fout.close();
}
bool MSD::Aggregate() const
{
ifstream fin(m_tmpModel);
if (!fin){
cerr << "Cannot find file msd.reordering.model.1.sorted" << endl;
return false;
}
ofstream fout(m_tmpModel + ".aggregated");
if (!fout){
cerr << "Cannot create aggregation file: " <<
m_tmpModel + ".arggregated" << endl;
return false;
}
cerr << "MSD reordering Step2: Aggregating MSD scores..." << endl;
string line, lastsrc = "", lasttgt = "";
size_t score[6] = {0};
vector<string> msdscore;
while (getline(fin, line)){
vector<string> tmp = BasicMethod::Split(line, " ||| ");
if (tmp.size() != 3){
cerr << "msd reordering table bad data: "
<< line << endl;
continue;
}
if (lastsrc == "" && lasttgt == ""){
lastsrc = tmp[0]; lasttgt = tmp[1];
memset(score, 0, sizeof(score));
msdscore = BasicMethod::Split(tmp[2]);
for (int i = 0; i < 6; ++i){
score[i] = atoi(msdscore[i].c_str());
}
}
else{
if (tmp[0] == lastsrc && tmp[1] == lasttgt){
msdscore = BasicMethod::Split(tmp[2]);
for (int i = 0; i < 6; ++i){
score[i] += atoi(msdscore[i].c_str());
}
}
else{
//we now output the aggregation of previous pharse pair
fout << lastsrc << " ||| " << lasttgt << " ||| ";
for (int i = 0; i < 6; ++i){
if (i != 5){
fout << score[i] << " ";
}
else{
fout << score[i] << endl;
}
}
lastsrc = tmp[0]; lasttgt = tmp[1];
memset(score, 0, sizeof(score));
msdscore = BasicMethod::Split(tmp[2]);
for (int i = 0; i < 6; ++i){
score[i] = atoi(msdscore[i].c_str());
}
}
}
}
//output remaining items
fout << lastsrc << " ||| " << lasttgt << " ||| ";
for (int i = 0; i < 6; ++i){
if (i != 5){
fout << score[i] << " ";
}
else{
fout << score[i] << endl;
}
}
fout.close();
fin.close();
}
// Runs program with input from test files in testFiles vector.
void TestSuite::runTests()
{
int numCorrect = 0, numWrong = 0;
int i;
string name;
string logName;
string stored_dir;
double rate;
bool crit = false;
string crit_string = "crit.tst";
bool crit_passed = true;
char buff[40];
int chpid = 45;
//Get directory of current program
i = testProgram.rfind('.');
testProgram = testProgram.substr(0, i);
// Create log file.
logName = testProgram + "-";
logName += exeTime;
logName += ".log";
ofstream fout(logName.c_str());
if (!fout)
{
return;
}
// Iterate over test files.
vector<string>::iterator it;
for ( it = testFiles.begin(); it != testFiles.end() ; it++ )
{
//Determine if this is a critical test
if(it->find(crit_string) != string::npos)
{
crit = true;
}
// Get test file name without path.
size_t pos = it->rfind("/");
if(pos != std::string::npos)
{
name = it->substr(pos+1,it->length());
}
// Output test file name to log file.
fout << name;
// Run program with given test file.
run_code(*it,name);
//else, do a failed program log file i supposd
// Determine corresponding answer file.
string ans = *it;
ans.replace(ans.end()-4, ans.end(),answerExtension);
// Output results.
if (correct_answer(ans))
{
numCorrect++;
fout << ": PASS" << endl;
}
else
{
//If this was a crit test, they auto fail
if(crit)
{
crit_passed = false;
}
numWrong++;
fout << ": FAIL" << endl;
}
}
//If all possible crit tests were passed
if(crit_passed)
{
// Output pass and fail stats.
rate = ( numCorrect / (double)(numCorrect + numWrong) ) * 100;
fout << rate << "% CORRECT," << numCorrect << " PASSED," << numWrong << " FAILED";
sprintf(buff, " %f%% Correct\n", rate);
i = testProgram.rfind('/');
studentResults.push_back(testProgram.substr(i+1) + string(buff));
}
else
{
//If one or more were not passed
fout << "Failed: Did not pass one or more acceptance tests (Labeled as crit)" << endl;
i = testProgram.rfind('/');
studentResults.push_back(testProgram.substr(i) + " FAILED\n");
}
fout << "\n" << get_gcov(testProgram) << endl;
fout.close();
if(profiling)
get_gprof(testProgram);
}
bool EncoderLame::encode(QString input,QString output)
{
qDebug() << "[EncoderLame] Encoding" << QDir::cleanPath(input);
if(!m_symbolsResolved) {
qDebug() << "[EncoderLame] Symbols not successfully resolved, cannot run!";
return false;
}
QFile fin(input);
QFile fout(output);
// initialize encoder
lame_global_flags *gfp;
unsigned char header[12];
unsigned char chunkheader[8];
unsigned int datalength = 0;
unsigned int channels = 0;
unsigned int samplerate = 0;
unsigned int samplesize = 0;
int num_samples = 0;
int ret;
unsigned char* mp3buf;
int mp3buflen;
short int* wavbuf;
int wavbuflen;
gfp = m_lame_init();
m_lame_set_out_samplerate(gfp, 12000); // resample to 12kHz
// scale input volume
m_lame_set_scale(gfp, m_encoderVolume);
m_lame_set_mode(gfp, MONO); // mono output mode
m_lame_set_VBR(gfp, vbr_default); // enable default VBR mode
// VBR quality
m_lame_set_VBR_quality(gfp, m_encoderQuality);
m_lame_set_VBR_max_bitrate_kbps(gfp, 64); // maximum bitrate 64kbps
m_lame_set_bWriteVbrTag(gfp, 0); // disable LAME tag.
if(!fin.open(QIODevice::ReadOnly)) {
qDebug() << "[EncoderLame] Could not open input file" << input;
return false;
}
// read RIFF header
fin.read((char*)header, 12);
if(memcmp("RIFF", header, 4) != 0) {
qDebug() << "[EncoderLame] RIFF header not found!"
<< header[0] << header[1] << header[2] << header[3];
fin.close();
return false;
}
if(memcmp("WAVE", &header[8], 4) != 0) {
qDebug() << "[EncoderLame] WAVE FOURCC not found!"
<< header[8] << header[9] << header[10] << header[11];
fin.close();
return false;
}
// search for fmt chunk
do {
// read fmt
fin.read((char*)chunkheader, 8);
int chunkdatalen = chunkheader[4] | chunkheader[5]<<8
| chunkheader[6]<<16 | chunkheader[7]<<24;
if(memcmp("fmt ", chunkheader, 4) == 0) {
// fmt found, read rest of chunk.
// NOTE: This code ignores the format tag value.
// Ideally this should be checked as well. However, rbspeex doesn't
// check the format tag either when reading wave files, so if
// problems arise we should notice pretty soon. Furthermore, the
// input format used should be known. In case some TTS uses a
// different wave encoding some time this needs to get adjusted.
if(chunkdatalen < 16) {
qDebug() << "[EncoderLame] fmt chunk too small!";
}
else {
unsigned char *buf = new unsigned char[chunkdatalen];
fin.read((char*)buf, chunkdatalen);
channels = buf[2] | buf[3]<<8;
samplerate = buf[4] | buf[5]<<8 | buf[6]<<16 | buf[7]<<24;
samplesize = buf[14] | buf[15]<<8;
delete[] buf;
}
}
// read data
else if(memcmp("data", chunkheader, 4) == 0) {
datalength = chunkdatalen;
break;
}
else {
// unknown chunk, just skip its data.
qDebug() << "[EncoderLame] unknown chunk, skipping."
<< chunkheader[0] << chunkheader[1]
<< chunkheader[2] << chunkheader[3];
fin.seek(fin.pos() + chunkdatalen);
}
} while(!fin.atEnd());
// check format
if(channels == 0 || samplerate == 0 || samplesize == 0 || datalength == 0) {
qDebug() << "[EncoderLame] invalid format. Channels:" << channels
<< "Samplerate:" << samplerate << "Samplesize:" << samplesize
<< "Data chunk length:" << datalength;
fin.close();
return false;
}
num_samples = (datalength / channels / (samplesize/8));
// set input format values
m_lame_set_in_samplerate(gfp, samplerate);
m_lame_set_num_channels(gfp, channels);
// initialize encoder.
ret = m_lame_init_params(gfp);
if(ret != 0) {
qDebug() << "[EncoderLame] lame_init_params() failed with" << ret;
fin.close();
return false;
}
// we're dealing with rather small files here (100kB-ish), so don't care
// about the possible output size and simply allocate the same number of
// bytes the input file has. This wastes space but should be ok.
// Put an upper limit of 8MiB.
if(datalength > 8*1024*1024) {
qDebug() << "[EncoderLame] Input file too large:" << datalength;
fin.close();
return false;
}
mp3buflen = datalength;
wavbuflen = datalength;
mp3buf = new unsigned char[mp3buflen];
wavbuf = new short int[wavbuflen];
#if defined(Q_OS_MACX)
// handle byte order -- the host might not be LE.
if(samplesize == 8) {
// no need to convert.
fin.read((char*)wavbuf, wavbuflen);
}
else if(samplesize == 16) {
// read LE 16bit words. Since the input format is either mono or
// interleaved there's no need to care for that.
unsigned int pos = 0;
char word[2];
while(pos < datalength) {
fin.read(word, 2);
wavbuf[pos++] = (word[0]&0xff) | ((word[1]<<8)&0xff00);
}
}
else {
qDebug() << "[EncoderLame] Unknown samplesize:" << samplesize;
fin.close();
delete[] mp3buf;
delete[] wavbuf;
return false;
}
#else
// all systems but OS X are considered LE.
fin.read((char*)wavbuf, wavbuflen);
#endif
fin.close();
// encode data.
fout.open(QIODevice::ReadWrite);
ret = m_lame_encode_buffer(gfp, wavbuf, wavbuf, num_samples, mp3buf, mp3buflen);
if(ret < 0) {
qDebug() << "[EncoderLame] Error during encoding:" << ret;
}
if(fout.write((char*)mp3buf, ret) != (unsigned int)ret) {
qDebug() << "[EncoderLame] Writing mp3 data failed!" << ret;
fout.close();
delete[] mp3buf;
delete[] wavbuf;
return false;
}
// flush remaining data
ret = m_lame_encode_flush(gfp, mp3buf, mp3buflen);
if(fout.write((char*)mp3buf, ret) != (unsigned int)ret) {
qDebug() << "[EncoderLame] Writing final mp3 data failed!";
fout.close();
delete[] mp3buf;
delete[] wavbuf;
return false;
}
// shut down encoder and clean up.
m_lame_close(gfp);
fout.close();
delete[] mp3buf;
delete[] wavbuf;
return true;
}
void HMMObserver::start() {
vector<vector<TimeSeries *> *> chunk_bins;
vector<double> current_means;
vector<double> current_ns;
vector<double> current_variance;
vector<TimeSeries *> chunks;
TimeSeries * inputTS = NULL;
if (use_csv) {
inputTS = CSVLoader::loadTSfromCSV(csvin_fname);
} else {
log_e("No input source defined. Stop.");
return;
}
#define NUM_STEPS 5
TimeSeries * inputRaw = inputTS->copy();
TRANS_DETECTOR.setParams(0.05,60);
double NEW_BIN_THRESH = 1.2;
log_prog(1,NUM_STEPS,"Detect Transitions","");
EventSeries<TransitionEvent> * es = TRANS_DETECTOR.detect(inputTS);
log_i("%d Transitions found\n",es->events.size());
if ( es->events.size() <= 1 ) {
log_i("Not enough transitions to do anything useful");
log_prog(NUM_STEPS,NUM_STEPS,"Early abort","No data");
error = 1;
return;
}
// STEP Ia : SEPARATE INTO CHUNKS
log_prog(2,NUM_STEPS,"Separate Time Chunks","");
chunks.push_back(inputTS->selectTime(inputTS->t[0],es->events[0].t));
for ( size_t c = 0; c < es->events.size() - 1; c++) {
chunks.push_back(inputTS->selectTime(es->events[c].t,es->events[c+1].t));
}
chunks.push_back(inputTS->selectTime(es->events[es->events.size()-1].t,inputTS->t[inputTS->t.size()-1]));
if (csvout_fname.size() > 0) {
TimeSeries * tsout = new TimeSeries();
tsout->metadata.push_back(" Data separated into chunks via the transition detector");
for (size_t c = 0; c < chunks.size(); c++) {
tsout->insertPointAtEnd(chunks[c]->t[0],chunks[c]->mean());
}
CSVLoader::writeTStoCSV(csvout_fname,tsout,outprec);
delete tsout;
}
if (statesin_fname.size() > 0 ) {
// STEP Ib : ORDER CHUNKS BY SIZE
log_prog(3,NUM_STEPS,"Order by Size","");
sort(chunks.begin(), chunks.end(), cmp_by_timeseries_length);
// STEP Ic : CATAGORIZE CHUNKS BY MEANS
// start with biggest chunk in first bin
chunk_bins.push_back(new vector<TimeSeries *>);
chunk_bins[0]->push_back(chunks[0]);
current_means.push_back(chunks[0]->mean());
for ( int c = 1; c < chunks.size(); c++ ) {
log_prog(4,NUM_STEPS,"Categorize by Means","%.2f%%",(100.0*c/chunks.size()));
double chmean = chunks[c]->mean();
// find the "closest" bin
int minmean = 0;
for ( int d = 1; d < chunk_bins.size(); d++ ) {
if ( fabs(chmean - current_means[d]) < fabs(chmean - current_means[minmean]) ) {
minmean = d;
}
}
// if closest bin is too far off, create a new bin
if ( current_means[minmean] / chmean > NEW_BIN_THRESH || chmean / current_means[minmean] > NEW_BIN_THRESH ) {
chunk_bins.push_back(new vector<TimeSeries *>);
chunk_bins.back()->push_back(chunks[c]);
current_means.push_back(chmean);
} else { // add to bin and update mean
current_means[minmean] = (current_means[minmean] * chunk_bins[minmean]->size() + chmean) / (chunk_bins[minmean]->size() + 1);
chunk_bins[minmean]->push_back(chunks[c]);
}
}
for ( int c = 0; c < chunk_bins.size(); c++ ) {
int varn = 0;
double varsum = 0;
double meansum = 0;
for (int d = 0; d < chunk_bins[c]->size(); d++ ) {
varn += chunk_bins[c]->at(d)->t.size();
}
current_ns.push_back(varn);
// recalculate means
for ( int d = 0; d < chunk_bins[c]->size(); d++ ) {
meansum += chunk_bins[c]->at(d)->sum();
}
meansum = current_means[c] = meansum/varn;
for (int d = 0; d < chunk_bins[c]->size(); d++ ) {
varn += chunk_bins[c]->at(d)->t.size();
for ( int e = 0; e < chunk_bins[c]->at(d)->t.size(); e++) {
double tsq = chunk_bins[c]->at(d)->v[e] - meansum;
varsum += tsq * tsq;
}
}
current_variance.push_back(varsum / varn);
}
for ( int c = 0; c < chunk_bins.size(); c++ ) {
log_i("Cluster %2d : Mean %10.2f Variance %10.2f",c,current_means[c],current_variance[c]);
for ( int d = 0; d < chunk_bins[c]->size(); d++) {
log_i("\tChunk %3d: t:%10.2f mean:%10.2f",d,chunk_bins[c]->at(d)->t.front() - inputTS->t.front(),chunk_bins[c]->at(d)->mean());
}
}
log_prog(5,NUM_STEPS,"Writing Output","");
ofstream fout(statesin_fname.c_str());
fout.precision(outprec);
if ( !fout.is_open() ) {
log_e("Cannot open file %s for writing: %s",statesin_fname.c_str(),strerror(errno));
exit(2);
}
fout << "# Describes states and their statistical measurements"<<endl;
fout<< "# State, sample size, Mean, Variance"<<endl;
for ( int c = 0; c < chunk_bins.size(); c++ ){
fout << c << "," << current_ns[c] << "," << current_means[c] << "," << current_variance[c] << endl;
}
fout.close();
}
cleanup:
// cleanup
while(!chunk_bins.empty()) delete chunk_bins.back(), chunk_bins.pop_back();
while(!chunks.empty()) delete chunks.back(), chunks.pop_back();
delete es;
delete inputTS;
delete inputRaw;
log_i("Done.");
}
int main(int argc, char* argv[])
{
directory_structure_t ds;
vector<object_trj_t> good_trlet_list;
{
std::string name = ds.workspace+"good_trlet_list.xml";
std::ifstream fin(name.c_str());
boost::archive::xml_iarchive ia(fin);
ia >> BOOST_SERIALIZATION_NVP(good_trlet_list);
}
if(good_trlet_list.size()==0)
{
std::cout<<"reading good_trlet_list.xml fails."<<std::endl;
return 1;
}
int Ncam = good_trlet_list(0).trj.size();
vector<object_trj_t> final_trj_list;
vector<vector<int> > final_trj_index;
matrix<int> final_state_list;
{
std::string name = ds.workspace+"final_trj_list_alone.xml";
std::ifstream fin(name.c_str());
boost::archive::xml_iarchive ia(fin);
ia >> BOOST_SERIALIZATION_NVP(final_trj_list);
}
{
std::string name = ds.workspace+"final_state_list_alone.txt";
std::ifstream fin(name.c_str());
fin>>final_state_list;
fin.close();
}
{
std::string name = ds.workspace+"final_trj_index_alone.txt";
std::ifstream fin(name.c_str());
fin >> final_trj_index;
fin.close();
}
int len_thr = 4;
vector<object_trj_t> merged_trj_list;
vector<vector<int> > merged_trj_index;
matrix<int> merged_state_list;
post_process_trj(good_trlet_list, final_trj_list, final_trj_index,
final_state_list, Ncam, len_thr,
merged_trj_list, merged_trj_index,
merged_state_list);
{
std::string name = ds.workspace+"merged_trj_list_alone.xml";
std::ofstream fout(name.c_str());
boost::archive::xml_oarchive oa(fout);
oa << BOOST_SERIALIZATION_NVP(merged_trj_list);
}
{
std::string name = ds.workspace+"merged_trj_index_alone.txt";
std::ofstream fout(name.c_str());
fout<<merged_trj_index;
fout.close();
}
{
std::string name = ds.workspace+"merged_state_list_alone.txt";
std::ofstream fout(name.c_str());
fout << merged_state_list;
fout.close();
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
/* add valid user */
valid_user.Add(_T("mr_timon"));
valid_user.Add(_T("mr_pumbaa"));
valid_user.Add(_T("star_patrick"));
valid_user.Add(_T("乐乐是我的哦"));
valid_user.Add(_T("457800643xc"));
valid_user.Add(_T("lingzhiji服饰旗舰店"));
valid_user.Add(_T("呢好美"));
//valid_user.Add(_T("star"));
//valid_user.Add(_T("lele"));
if(checkUser(argv[2])){
std::cout << std::endl << std::endl << " you are not a valid user! " << std::endl << std::endl << std::endl;
return 0;
}
CString URL;
CString url_date;
CString url_spm = _T("spm=1.7274553.1997520841.1");
CString url_keyWord ;
CString url_option = _T("commend=all&ssid=s5-e&search_type=item&sourceId=tb.index");
CString url_head = _T("http://s.taobao.com/search?");
CString url_page;
CString filePath = _T("dist");
//CString string_keyWord = _T("儿童防紫外线帽子");
//CString string_id = _T("mr_timon");
CString string_keyWord = argv[1];
CString string_id = argv[2];
url_date = _T("initiative_id=tbindexz_") + generateUrlDate();
url_keyWord = _T("q=") + generateUrlKeyWord(string_keyWord);
for(int i = 1; i <= 100; i++){
url_page = generateUrlPage(i);
if((i - 1)%10 == 0){
std::cout << " searching";
for(int j = 0; j < i/10; j++){
std::cout << ".";
}
std::cout << std::endl;
}
if(i != 1){
URL = url_head + url_keyWord + _T("&") + url_spm + _T("&") + url_option+ _T("&") + url_date + _T("&") + url_page;
}else{
URL = url_head + url_keyWord + _T("&") + url_spm + _T("&") + url_option+ _T("&") + url_date;
}
/* 这里有资源链接的话，可以把对应的资源下载下来 */
//URL = _T("http://www.jojomamanbebe.co.uk/products/images/large/B2755C.jpg");
HRESULT result = URLDownloadToFile(0, URL, filePath, 0, NULL);
if(result == S_OK){
//std::cout << "down\n";
if(!searchLocation(filePath,string_id)){
std::cout << " page = " << i << std::endl << std::endl << std::endl;
break;
}else{
if(i == 100)
std::cout << std::endl << std::endl << "************* sorry,we don't have found it *************" << std::endl << std::endl << std::endl ;
}
}else{
std::cout << "URLDownloadToFile failed\n";
return 1;
}
}
//std::cout << "real_url = " << URL << std::endl;
std::ofstream fout("currentURL.txt");
fout << URL;
fout.flush();
fout.close();
//getchar();
return 0;
}
template<typename real> void
pcl::BivariatePolynomialT<real>::writeBinary (const char* filename) const
{
std::ofstream fout (filename);
writeBinary (fout);
}
int main() {
std::string filename="MyFile.txt"; //' '
std::ofstream /* ifstream */ fout(filename.c_str()); // (filename)
fout << /* >> */ "Hello World" << std::endl;
fout.close(); //finish
}
//----------------------------------------------------------------
void GetImageH264(AV2000F& dll, PARAMS& params)
{
// using client
unsigned long size = 1024*1024, capacity = 1024*1024;
char* data = new char[size]; // image
int ret;
if(ret = dll.pCreateClient(1))
{
std::cout << "\nerror on create client, code: " << ret << '\n';
return;
}
dll.pSetClientIp(1, params["-ip"].c_str());
dll.pSetClientBuffer(1, data, size);
if(dll.pUpdateVersion(1) )
{
//if(!dll.pGetDefaultImage(1, &data, &size, &capacity)) return;
PARAMS::iterator iter = params.find("-out"); // out file with image
if(iter == params.end()) params["-out"] = "test.mpg";
std::ofstream fout(params["-out"].c_str(), std::ios_base::binary);
std::cout << "Camera model: " << dll.pModel(1) << " / " << dll.pVersion(1) << '\n';
if(!fout)
std::cout << "can't open file\n";
else
{
IMAGE_RESOLUTION res = imFULL;
if((iter = params.find("-res")) != params.end())
if(iter->second == "half") res = imHALF;
long quality = 15; //
int left = 0, top = 0, width = 1600, height = 1184;
int codec = H264_CODEC;
int streamId = 1;
int kbps = 0;// bit rate control off
int IntraFramePeriod = 0;// if bit rate control off, then this value is ignored
for (int frame=0; frame < 25; ++frame)
{
int IFrame = 0; //request P frame if possible. if not available
//SDK will change it to 1, so it must be set every time
ret = dll.pGetWindowImageQEx(1, &data, &size , &capacity, imFULL, 0, quality, left, top, width, height, codec, streamId, &IFrame, kbps, IntraFramePeriod);
std::cout << " return " << size << "bytes" << '\n';
for(unsigned long i = 0; i < size; i++)
fout << data[i];
}
std::cout << "image saved to file: \"" << params["-out"] << "\"\n";
}
}
else
{
const ClientError* pcler = dll.pGetLastClientError(1);
std::cout << "error: code: " << pcler->code << ", description: " << pcler->description << '\n';
}
dll.pDestroyClient(1);
}
void ShearCatalog::writeAscii(std::string file, std::string delim) const
{
Assert(int(_id.size()) == size());
Assert(int(_pos.size()) == size());
Assert(int(_sky.size()) == size());
Assert(int(_noise.size()) == size());
Assert(int(_flags.size()) == size());
Assert(int(_skypos.size()) == size());
Assert(int(_shear.size()) == size());
Assert(int(_nu.size()) == size());
Assert(int(_cov.size()) == size());
Assert(int(_meas_galorder.size()) == size());
Assert(int(_shape.size()) == size());
std::ofstream fout(file.c_str());
if (!fout) {
throw WriteException("Error opening shear file"+file);
}
bool output_psf = _params.read("shear_output_psf",false);
Form sci8; sci8.sci().trail(0).prec(8);
Form fix3; fix3.fix().trail(0).prec(3);
Form fix8; fix8.fix().trail(0).prec(8);
Form fix6; fix6.fix().trail(0).prec(6);
const int ngals = size();
for(int i=0;i<ngals;++i) {
fout
<< _id[i] << delim
<< fix3(_pos[i].getX()) << delim
<< fix3(_pos[i].getY()) << delim
<< fix3(_sky[i]) << delim
<< sci8(_noise[i]) << delim
<< _flags[i] << delim
<< fix8(_skypos[i].getX()/3600.) << delim
<< fix8(_skypos[i].getY()/3600.) << delim
<< sci8(real(_shear[i])) << delim
<< sci8(imag(_shear[i])) << delim
<< fix3(_nu[i]) << delim
<< sci8(_cov[i](0,0)) << delim
<< sci8(_cov[i](0,1)) << delim
<< sci8(_cov[i](1,1)) << delim
//<< _shape[i].getOrder() << delim
<< _meas_galorder[i] << delim
<< fix6(_shape[i].getSigma());
const int ncoeff = _shape[i].size();
for(int j=0;j<ncoeff;++j)
fout << delim << sci8(_shape[i](j));
if (output_psf) {
Assert(_fitpsf);
BVec interp_psf(_fitpsf->getPsfOrder(),_fitpsf->getSigma());
interp_psf = (*_fitpsf)(_pos[i]);
fout
<< delim << interp_psf.getOrder()
<< delim << fix6(interp_psf.getSigma());
const int npsf_coeff = interp_psf.size();
for(int j=0;j<npsf_coeff;++j)
fout << delim << sci8(interp_psf(j));
}
fout << std::endl;
}
}
void TalkCard::handleVCard(const JID & jid, const VCard * vcard)
{
if (!vcard) {
DLOG("empty %s's vcard!\n", jid.full().c_str());
return ;
}
Bodies& bodies = Bodies::Get_Bodies();
const JID& myjid = bodies.get_jid();
char *random =
g_strdup_printf("%x", g_random_int());
const char *dirname = GUnit::getIconPath();
char *filename =
g_build_filename(dirname, random, NULL);
int f_size;
int n_size;
struct stat f_stat;
DLOG("geting %s vcard\n", jid.username().c_str());
//获取自己的vcard照片
if (myjid.bare() == jid.bare()) {
//bodies.set_vcard(vcard);
const std::string m_file = bodies.getAccountTag("icon");
if ((!m_file.empty())
&& (!access(m_file.c_str(), F_OK))) {
if (stat(m_file.c_str(), &f_stat))
return ;
f_size = f_stat.st_size;
} else
f_size = 0;
if (!vcard->photo().type.empty()) {
n_size = vcard->photo().binval.size();
if (f_size != n_size) {
DLOG("orig picture size = %d,new size= %d\n", f_size, n_size);
std::ofstream fout(filename);
fout.write((const char *) vcard->
photo().binval.c_str(),
vcard->photo().binval.
size());
fout.close();
bodies.setAccountTag("icon", filename);
bodies.get_main_window().set_logo(filename);
}
}
}
Buddy *buddy =
bodies.get_buddy_list().find_buddy(jid.
bare
());
assert(buddy);
//buddy->set_vcard(vcard);
const std::string & buddyname = buddy->get_jid();
const std::string & f_file =
bodies.get_main_window().get_buddy_view().getBlistTag("buddy", buddyname, "icon");
if ((!f_file.empty())
&& (!access(f_file.c_str(), F_OK))) {
if (stat(f_file.c_str(), &f_stat))
return ;
f_size = f_stat.st_size;
} else
f_size = 0;
if (!vcard->photo().binval.empty()) {
n_size = vcard->photo().binval.size();
if (f_size != n_size) {
DLOG("orig picture size = %d,new size= %d\n", f_size, n_size);
std::ofstream fout(filename);
fout.write((const char *) vcard->
photo().binval.c_str(),
n_size);
fout.close();
bodies.get_main_window().get_buddy_view().setBlistTag("buddy",
buddyname,
"icon",
filename);
}
}
buddy->refreshinfo();
}
/**
* The main entry of dw-lr-train, whose goal
* is to takes as input in the same format as
* libsvm, and train a classifier.
**/
int main(int argc, char ** argv){
/**
* First, parse command line input to get
* (1) step size
* (2) number of epoches to run
* (3) regularization (l2)
**/
std::string filename;
int flags, opt;
int nsecs, tfnd;
nsecs = 0;
tfnd = 0;
flags = 0;
while ((opt = getopt(argc, argv, "s:e:r:")) != -1) {
switch (opt) {
case 's':
stepsize = atof(optarg);
break;
case 'e':
epoches = atof(optarg);
break;
case 'r':
lambda = atof(optarg);
break;
default:
fprintf(stderr, "Usage: %s [-s stepsize] [-e epoches] [-r regularization] trainfile\n", argv[0]);
exit(EXIT_FAILURE);
}
}
if (optind >= argc) {
fprintf(stderr, "Expected argument after options\n");
exit(EXIT_FAILURE);
}
filename = std::string(argv[optind]);
printf("stepsize=%f; epoches=%f; lambda=%f\n", stepsize, epoches, lambda);
printf("trainfile = %s\n", filename.c_str());
/**
* Second, create corpus
**/
size_t n_elements, n_examples, n_features;
double * p_examples;
long * p_cols;
long * p_rows;
get_corpus_stats(filename.c_str(), &n_elements, &n_examples);
n_features = create_dw_corpus(filename.c_str(), n_elements, n_examples, p_examples, p_cols, p_rows);
printf("#elements=%zu; #examples=%zu; #n_features=%zu\n", n_elements, n_examples, n_features);
/**
* Third, create DimmWitted object, and let it run.
**/
GLMModelExample_Sparse model(n_features);
for(int i=0;i<model.n;i++){
model.p[i] = 0.0;
}
SparseDimmWitted<double, GLMModelExample_Sparse, DW_MODELREPL_PERMACHINE, DW_DATAREPL_SHARDING, DW_ACCESS_ROW>
dw(p_examples, p_rows, p_cols, n_examples, n_features+1, n_elements, &model);
unsigned int f_handle_grad = dw.register_row(f_lr_grad_sparse);
unsigned int f_handle_loss = dw.register_row(f_lr_loss_sparse);
dw.register_model_avg(f_handle_grad, f_lr_modelavg);
dw.register_model_avg(f_handle_loss, f_lr_modelavg);
printf("Start training...\n");
double sum = 0.0;
for(int i_epoch=0;i_epoch<epoches;i_epoch++){
double loss = dw.exec(f_handle_loss)/n_examples;
std::cout << "loss=" << loss << std::endl;
dw.exec(f_handle_grad);
}
/**
* Forth, dump result.
**/
printf("Dumping training result to %s.model...\n", filename.c_str());
std::ofstream fout((filename + ".model").c_str());
fout << n_features << std::endl;
for(int i=0;i<model.n;i++){
fout << model.p[i] << std::endl;
}
fout.close();
exit(EXIT_SUCCESS);
}
int sql()
{
char f_l[4][15]={"employee","payroll","spending","expendit"};
char fn[15];
clrscr();
char comm[30]="w";
char name[20];int am;unsigned long int ac;
cout<<"This Server supports miniSQL. Use q to exit";
NL
cputs("#");int r=1;
cin.getline(comm,30);
do{
strcpy(fn,f_l[cfn]);
cin.getline(comm,30);
if(strstr(comm,"insert")==comm)
{
if(strstr(comm,"into")!=NULL)
{
if(strstr(comm,fn)!=NULL)
{
NL
cout<<"Enter Name: ";
gets(name);
cout<<"Enter Amount: ";
cin>>am;
do{
cout<<"Enter Account No: ";
cin>>ac;}while(ac<111111||ac>999999);
ofstream fout(strcat(fn,".dbf"),ios::app);
strcpy(fn,f_l[cfn]);
fout<<name<<"\t\t$"<<am<<"\t\t"<<ac<<endl;
p.cash+=am;
NL
if(abs(am-avg)<500)
r=1;
else
r=0;
} }
}
else if(strstr(comm,"select")==comm)
{
if(strstr(comm,"from")!=NULL)
{
if(strstr(comm,fn)!=NULL)
{
NL
if(strstr(comm,"*")!=NULL)
{
ifstream f(strcat(fn,".dbf"));
char *p;
while(f)
{
f.getline(p,50);
cout<<p<<endl;
}
f.close();
strcpy(fn,"");
}
else if(strstr(comm,"avg")!=NULL)
{
NL
cout<<"Average="<<avg;
}
}
}
}
/**
* \brief Faz o dump dos dados da Halo_Top para o arquivo de nome filename.
*
* @param [in] filename Nome do arquivo.
*/
void Halo_Top::print_iter_to_file(const char *filename) {
if (this->rank_neighbor == MPI_PROC_NULL) {
return;
}
fstream fout(filename, fstream::out | fstream::app);
fout << "Source:" << endl;
for (int i = 0; i < this->get_num_halos(); i++) {
for (halo_iterator hi = h_source[i]->first();; hi++) {
fout << *hi << " ";
if (hi == h_source[i]->last()) {
break;
}
}
fout << endl;
}
fout << "Dest:" << endl;
for (int i = 0; i < this->get_num_halos(); i++) {
for (halo_iterator hi = h_dest[i]->first();; hi++) {
fout << *hi << " ";
if (hi == h_dest[i]->last()) {
break;
}
}
fout << endl;
}
this->swap();
fout << "Source:" << endl;
for (int i = 0; i < this->get_num_halos(); i++) {
for (halo_iterator hi = h_source[i]->first();; hi++) {
fout << *hi << " ";
if (hi == h_source[i]->last()) {
break;
}
}
fout << endl;
}
fout << "Dest:" << endl;
for (int i = 0; i < this->get_num_halos(); i++) {
for (halo_iterator hi = h_dest[i]->first();; hi++) {
fout << *hi << " ";
if (hi == h_dest[i]->last()) {
break;
}
}
fout << endl;
}
fout.close();
return;
}
void scan_airspaces(const AIRCRAFT_STATE state,
const Airspaces& airspaces,
const AirspaceAircraftPerformance& perf,
bool do_report,
const GeoPoint &target)
{
const fixed range(20000.0);
const std::vector<Airspace> vn = airspaces.scan_nearest(state.Location);
AirspaceVisitorPrint pvn("results/res-bb-nearest.txt",
do_report);
std::for_each(vn.begin(), vn.end(), CallVisitor<AirspaceVisitor>(pvn));
{
AirspaceVisitorPrint pvisitor("results/res-bb-range.txt",
do_report);
airspaces.visit_within_range(state.Location, range, pvisitor);
}
{
AirspaceVisitorClosest pvisitor("results/res-bb-closest.txt",
state, perf);
airspaces.visit_within_range(state.Location, range, pvisitor);
}
{
const std::vector<Airspace> vi = airspaces.find_inside(state);
AirspaceVisitorPrint pvi("results/res-bb-inside.txt",
do_report);
std::for_each(vi.begin(), vi.end(), CallVisitor<AirspaceVisitor>(pvi));
}
{
AirspaceIntersectionVisitorPrint ivisitor("results/res-bb-intersects.txt",
"results/res-bb-intersected.txt",
"results/res-bb-intercepts.txt",
do_report,
state, perf);
GeoVector vec(state.Location, target);
airspaces.visit_intersecting(state.Location, vec, ivisitor);
}
{
AirspaceNearestSort ans(state.Location);
const AbstractAirspace* as = ans.find_nearest(airspaces, range);
if (do_report) {
std::ofstream fout("results/res-bb-sortednearest.txt");
if (as) {
fout << *as << "\n";
} else {
fout << "# no nearest found\n";
}
}
}
{
AirspaceSoonestSort ans(state, perf);
const AbstractAirspace* as = ans.find_nearest(airspaces);
if (do_report) {
std::ofstream fout("results/res-bb-sortedsoonest.txt");
if (as) {
fout << *as << "\n";
} else {
fout << "# no soonest found\n";
}
}
}
}
//
// This is an example ROOT macro to show how to use a KAmper
//
void testSimpleKamper(const char* input, const char * out)
{
KDataReader f(input);
TH1D hAmpHA("hAmpHeatA", "hAmpHeatA", 10000,-5000, 5000);
TH1D hAmpHC("hAmpHeatC", "hAmpHeatC", 10000,-5000, 5000);
TH1D hAmpIA("hAmpIonA", "hAmpIonA", 10000,-5000, 5000);
TH1D hAmpIB("hAmpIonB", "hAmpIonB", 10000,-5000, 5000);
TH1D hAmpIC("hAmpIonC", "hAmpIonC", 10000,-5000, 5000);
TH1D hAmpID("hAmpIonD", "hAmpIonD", 10000,-5000, 5000);
KEvent *e = f.GetEvent();
KPulseAnalysisRecord *prec = new KPulseAnalysisRecord;
KSimpleKamper1 myKamper;
int heatMinPeak = 250;
int heatMaxPeak = 290;
int ionMinPeak = 6500;
int ionMaxPeak = 6700;
for(Int_t i = 0; i < f.GetEntries(); i++){
f.GetEntry(i);
if (i % 500 == 0) cout << "entry " << i << endl;
for(Int_t j = 0; j < e->GetNumBoloPulses(); j++){
KRawBoloPulseRecord *p = (KRawBoloPulseRecord *)e->GetBoloPulse(j);
if( strcmp(p->GetBolometerRecord()->GetDetectorName(), "FID802") != 0)
continue;
if(p->GetPulseLength() == 0)
continue;
myKamper.MakeKamp(p,prec);
string name = p->GetChannelName();
if(strcmp(p->GetChannelName(),"chaleur FID802AB") == 0){
if(prec->GetPeakPosition() > heatMinPeak && prec->GetPeakPosition() < heatMaxPeak)
hAmpHA.Fill(prec->GetAmp());
}
else if(strcmp(p->GetChannelName(),"centre FID802AB") == 0){
if(prec->GetPeakPosition() > ionMinPeak && prec->GetPeakPosition() < ionMaxPeak)
hAmpIA.Fill(prec->GetAmp());
}
else if(strcmp(p->GetChannelName(),"garde FID802AB") == 0){
if(prec->GetPeakPosition() > ionMinPeak && prec->GetPeakPosition() < ionMaxPeak)
hAmpIB.Fill(prec->GetAmp());
}
else if(strcmp(p->GetChannelName(),"chaleur FID802CD") == 0){
if(prec->GetPeakPosition() > heatMinPeak && prec->GetPeakPosition() < heatMaxPeak)
hAmpHC.Fill(prec->GetAmp());
}
else if(strcmp(p->GetChannelName(),"centre FID802CD") == 0){
if(prec->GetPeakPosition() > ionMinPeak && prec->GetPeakPosition() < ionMaxPeak)
hAmpIA.Fill(prec->GetAmp());
}
else if(strcmp(p->GetChannelName(),"garde FID802CD") == 0){
if(prec->GetPeakPosition() > ionMinPeak && prec->GetPeakPosition() < ionMaxPeak)
hAmpIB.Fill(prec->GetAmp());
}
}
}
TFile fout(out,"recreate");
hAmpHA.Write();
hAmpHC.Write();
hAmpIA.Write();
hAmpIB.Write();
hAmpIC.Write();
hAmpID.Write();
}
int MainWindow::CliwocConverter( const QString &s_FilenameIn, const QString &s_FilenameOut, const QString &s_FilenameConf, const int i_NumOfFiles )
{
int k = 0;
int n = 0;
QString InputStr = "";
QString s_EventLabel = "";
QStringList sl_Conf;
unsigned int ui_length = 1;
unsigned int ui_filesize = 1;
// **********************************************************************************************
n = readFile( s_FilenameConf, sl_Conf );
if ( n < 9 )
return( _ERROR_ );
// **********************************************************************************************
// open input file
QFile fin( s_FilenameIn );
if ( fin.open( QIODevice::ReadOnly | QIODevice::Text ) == false )
return( -10 );
ui_filesize = fin.size();
QTextStream tin( &fin );
// **********************************************************************************************
// open output file
QFile fout( s_FilenameOut );
if ( fout.open( QIODevice::WriteOnly | QIODevice::Text ) == false )
return( -20 );
QTextStream tout( &fout );
// **********************************************************************************************
initProgress( i_NumOfFiles, s_FilenameIn, tr( "Converting..." ), 100 );
// **********************************************************************************************
// read file
// Header
tout << k++ << "\t" << "Event label" << "\t" << "Date/Time" << "\t" << "Latitude" << "\t" << "Longitude";
for ( int i=9; i<n; i++ )
{
if ( sl_Conf.at( i ).section( "\t", 0, 0 ) == "x" )
tout << "\t" << sl_Conf.at( i ).section( "\t", 3, 3 ); // Column no 4: Parameter name
}
tout << endl;
while ( ( tin.atEnd() == false ) && ( ui_length != (unsigned int) _APPBREAK_ ) )
{
InputStr = tin.readLine();
ui_length = incProgress( i_NumOfFiles, ui_filesize, ui_length, InputStr );
// Event label
s_EventLabel = "@" + InputStr.mid( 34, 9 ).simplified() + "_" + InputStr.mid( 2597, 8 ).simplified() + "_" + InputStr.mid( 297, 30 ).simplified();
s_EventLabel.replace( "EXTRACT ", "" );
s_EventLabel.replace( ",", "" );
s_EventLabel.replace( ".", "" );
s_EventLabel.replace( "(", "-" );
s_EventLabel.replace( ")", "" );
s_EventLabel.replace( " ", "_" );
s_EventLabel.replace( "_-_", "_" );
s_EventLabel.replace( "_-", "_" );
s_EventLabel.replace( "-_", "_" );
s_EventLabel.replace( "__", "_" );
s_EventLabel.replace( "'", "" );
tout << k++ << "\t" << s_EventLabel << "\t";
// Date/Time
QString s_DateTime = InputStr.mid( 0, 4 ) + tr( "-" ) + InputStr.mid( 4, 2 ) + tr( "-" ) + InputStr.mid( 6, 2 ) + tr( "T" ) + InputStr.mid( 8, 2 ) + tr( ":" ) + InputStr.mid( 10, 2 );
s_DateTime.replace( " ", "0" );
tout << s_DateTime << "\t";
// Position
// Latitude
if ( InputStr.mid( 12, 5 ) != " " )
tout << InputStr.mid( 12, 5 ).toFloat()/100. << "\t";
else
tout << "\t";
// Longitude
if ( InputStr.mid( 17, 6 ) != " " )
{
float f_Longitude = InputStr.mid( 17, 6 ).toFloat()/100.;
if ( f_Longitude > 180. )
f_Longitude -=360;
tout << f_Longitude;
}
else
tout << "";
for ( int i=9; i<n; i++ )
{
if ( sl_Conf.at( i ).section( "\t", 0, 0 ) == "x" )
{
QString s_Factor = sl_Conf.at( i ).section( "\t", 1, 1 );
QString s_Entry = InputStr.mid( sl_Conf.at( i ).section( "\t", 4, 4 ).toInt()-1, sl_Conf.at( i ).section( "\t", 6, 6 ).toInt() ).simplified();
if ( s_Entry.isEmpty() == true )
{
tout << "\t";
}
else
{
if ( s_Factor == "T" )
{
s_Entry.replace( "\"", "''" );
tout << "\t~@" << s_Entry;
}
else
{
if ( s_Factor.isEmpty() == false )
tout << "\t" << s_Entry.toFloat()*s_Factor.toFloat();
else
tout << "\t" << s_Entry;
}
}
}
}
tout << endl;
}
resetProgress( i_NumOfFiles );
fin.close();
fout.close();
// **********************************************************************************************
if ( ui_length == (unsigned int) _APPBREAK_ )
return( _APPBREAK_ );
return( _NOERROR_ );
}
//
// Analyze_ECvsP - fit the EC/P vs P distributions
//
// fAna = output from eg2a DMS
// target = target name
//
void Analyze(char *fAna="Ana.root", char *target)
{
Int_t i, j;
const Int_t NPARAM = 3;
TH1D *h1D[NPHOTONS][NPARAM];
TH1D *h2D[NPHOTONS];
char HistName1D[50];
char strname[50];
char *yname[NPARAM] = {"Amplitude","Mean","Sigma"};
// open text file for the yields
char OutFile[100];
sprintf(OutFile,"ECtimeEClPhoton1_%s.dat",target);
ofstream fout(OutFile);
TCanvas *can[NPHOTONS]; // Canvas to plot histogram
Double_t par[3]={1.0,1.0,1.0};
TF1 *pol;
TF1 *sig;
// data files contain the trees
printf("Analyzing file %s\n",fAna);
TFile *fm = new TFile(fAna,"READ");
TDirectory *tmp = fm->GetDirectory("PhotonID");
for(j=0; j<NPHOTONS; j++){
sprintf(cname,"can%i",j+1);
sprintf(cname,"Canvas, Sector %i",j+1);
can[j] = new TCanvas(cname,ctitle,50*j,0,600,600);
can[j]->SetBorderMode(1); //Bordermode (-1=down, 0 = no border, 1=up)
can[j]->SetBorderSize(5);
gStyle->SetOptStat(1111);
can[j]->SetFillStyle(4000);
sprintf(HistName1D,"ECtimeEClPhoton%i",j+1);
h2D[j] = (TH1D*)tmp->Get(HistName1D);
can[j]->cd();
gPad->SetLeftMargin(Lmar);
gPad->SetRightMargin(Rmar);
gPad->SetFillColor(0);
h2D[j]->GetXaxis()->CenterTitle();
h2D[j]->GetYaxis()->CenterTitle();
h2D[j]->GetYaxis()->SetTitleOffset(yoff);
// h2D[j]->SetAxisRange(0.0,0.3,"X");
// h2D[j]->Draw("colz");
// h2D[j]->FitSlicesY(0,0,-1,20,"QNR");//TODO MAYBE
fout<<j+1<<"\t";
gPad->SetLeftMargin(Lmar);
gPad->SetRightMargin(Rmar);
gPad->SetFillColor(0);
sprintf(strname,"%s",HistName1D);
gaus = new TF1("gaus","gaus",-1,1); //ADJUST fit range
TFitResultPtr r = h2D[j]->Fit("gaus","R");
fout<<gaus->GetParameter(0)<<"\t"<<gaus->GetParameter(1)<<"\t"<<gaus->GetParameter(2)<<"\t";
h2D[j]->Draw();
sprintf(OutCan,"ECtimeEClPhoton%i_%s.gif",j+1,target);
can[j]->Print(OutCan);
sprintf(OutCan,"ECtimeEClPhoton%i_%s.eps",j+1,target);
can[j]->Print(OutCan);
}
fout.close(); // close the text file
}
void
RemapHDF4::saveTrimmed(QString trimFile,
int dmin, int dmax,
int wmin, int wmax,
int hmin, int hmax)
{
QProgressDialog progress("Saving trimmed volume",
"Cancel",
0, 100,
0);
progress.setMinimumDuration(0);
int nX, nY, nZ;
nX = m_depth;
nY = m_width;
nZ = m_height;
int mX, mY, mZ;
mX = dmax-dmin+1;
mY = wmax-wmin+1;
mZ = hmax-hmin+1;
int nbytes = m_height*m_width*m_bytesPerVoxel;
uchar *tmp = new uchar[nbytes];
uchar vt;
if (m_voxelType == _UChar) vt = 0; // unsigned byte
if (m_voxelType == _Char) vt = 1; // signed byte
if (m_voxelType == _UShort) vt = 2; // unsigned short
if (m_voxelType == _Short) vt = 3; // signed short
if (m_voxelType == _Int) vt = 4; // int
if (m_voxelType == _Float) vt = 8; // float
QFile fout(trimFile);
fout.open(QFile::WriteOnly);
fout.write((char*)&vt, 1);
fout.write((char*)&mX, 4);
fout.write((char*)&mY, 4);
fout.write((char*)&mZ, 4);
int32 start[2], edges[2];
start[0] = 0;
start[1] = 0;
edges[0] = m_width;
edges[1] = m_height;
for(uint i=dmin; i<=dmax; i++)
{
int32 sd_id = SDstart(m_imageList[i].toAscii().data(),
DFACC_READ);
int32 sds_id = SDselect(sd_id, m_Index);
int status = SDreaddata(sds_id,
start, NULL, edges,
(VOIDP)tmp);
status = SDendaccess(sds_id);
status = SDend(sd_id);
for(uint j=wmin; j<=wmax; j++)
{
memcpy(tmp+(j-wmin)*mZ*m_bytesPerVoxel,
tmp+(j*nZ + hmin)*m_bytesPerVoxel,
mZ*m_bytesPerVoxel);
}
fout.write((char*)tmp, mY*mZ*m_bytesPerVoxel);
progress.setValue((int)(100*(float)(i-dmin)/(float)mX));
qApp->processEvents();
}
fout.close();
delete [] tmp;
m_headerBytes = 13; // to be used for applyMapping function
}
