uint8_t * zip_read(app_t *app, const char *key, size_t *size) { struct zip_stat stat; if(!zip_stat(app->io, key, 0, &stat)) { size_t fsize = stat.size; struct zip_file *f = zip_fopen(app->io, key, 0); if(f) { uint8_t *str = malloc(fsize); if(str) { if(zip_fread(f, str, fsize) == -1) { free(str); str = NULL; fsize = 0; } else { ; //success } } zip_fclose(f); *size = fsize; return str; } } *size = 0; return NULL; }
extern int FileStat( const char *path, struct stat *buf ) { int rc; struct zip_stat zs; rc = -1; if( srcType == DS_ZIP ) { char *alt_path; /* First try a file inside a ZIP archive */ alt_path = flipBackSlashes( path ); if( alt_path != NULL ) { rc = zip_stat( srcZip, alt_path, 0, &zs ); if( rc == 0 ) { memset( buf, 0, sizeof( *buf ) ); buf->st_ino = zs.index; buf->st_size = zs.size; buf->st_mtime = zs.mtime; } free( alt_path ); } } if( rc != 0 ) { /* If that fails, try local file */ rc = stat( path, buf ); } return( rc ); }
QJsonArray File::get_decoders() { struct zip *archive; struct zip_file *zf; struct zip_stat zs; int ret; char *dec_file; QJsonArray dec_array; QJsonParseError error; archive = zip_open(_path.toLocal8Bit().data(), 0, &ret); if (archive) { /* read "decoders" */ if (zip_stat(archive, "decoders", 0, &zs) != -1) { dec_file = (char *)g_try_malloc(zs.size); if (dec_file) { zf = zip_fopen_index(archive, zs.index, 0); zip_fread(zf, dec_file, zs.size); zip_fclose(zf); //QString sessionData = QString::fromUtf8(dec_file); QJsonDocument sessionDoc = QJsonDocument::fromJson(QByteArray::fromRawData(dec_file, zs.size), &error); dec_array = sessionDoc.array(); } } } return dec_array; }
/************************************************* Function: readZipFileName Descroption: Input: 1.zip* z 2.filetype Output: Return: Other: *************************************************/ int readZipFileName(struct zip* z, char* filetype) { int i; struct zip_stat fstat; if(z != NULL) { zip_stat_init(&fstat); int c = zip_get_num_files(z); if(c > 0) { for (i = 0 ; i < c; i++) { const char* name = zip_get_name(z, i, 0); if(name != NULL) { zip_stat(z, name,0,&fstat); //LOGI("File %i:%s Size: %lld Size2: %lld\n", i,fstat.name,fstat.size ,fstat.comp_size); } } } } else { return -1; } return 0; }
const bool CCZipFile::open(const char *file) { // Grab the APK (zip) file to access resource m_apkArchive = zip_open( CCDeviceFileManager::apkPath.buffer, 0, NULL ); if( m_apkArchive == NULL ) { DEBUGLOG( "Error loading APK" ); return false; } // It's not an image, so add res/raw/ to the path to look in the correct directory CCText fullFilePath = "res/raw/"; fullFilePath += file; // Open the supplied file as read-only m_File = zip_fopen( m_apkArchive, fullFilePath.buffer, 0 ); if( m_File != NULL ) { // Get the file size struct zip_stat stat; zip_stat( m_apkArchive, fullFilePath.buffer, 0, &stat ); m_Size = stat.size; return true; } DEBUGLOG( "Error loading file %s: %s", fullFilePath.buffer, strerror( errno ) ); return false; }
ZipFileReader::ZipFileReader(ZipArchive& archive, const StringSlice& path) { struct zip_stat st; CString c_str(path); if (zip_stat(archive.c_obj(), c_str.data(), 0, &st) != 0) { throw Exception(format( "{0}: {1}: {2}", archive.path(), path, zip_error(archive.c_obj()))); } initialize(archive, st); }
bool ZIPProvider::ZIPHandle::isFile(const FileName & file) { struct zip_stat sb; zip_stat_init(&sb); if (zip_stat(handle, file.getPath().c_str(), 0, &sb) == -1) { return false; } std::string entry(sb.name); return (entry.back() != '/' && sb.size != 0); }
size_t ZIPProvider::ZIPHandle::fileSize(const FileName & file) { struct zip_stat sb; zip_stat_init(&sb); if (zip_stat(handle, file.getPath().c_str(), 0, &sb) == -1) { WARN(zip_strerror(handle)); return 0; } return static_cast<size_t>(sb.size); }
/** @private */ SR_PRIV int sr_sessionfile_check(const char *filename) { struct zip *archive; struct zip_file *zf; struct zip_stat zs; uint64_t version; int ret; char s[11]; if (!filename) return SR_ERR_ARG; if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) { sr_err("Not a regular file: %s.", filename); return SR_ERR; } if (!(archive = zip_open(filename, 0, NULL))) /* No logging: this can be used just to check if it's * a sigrok session file or not. */ return SR_ERR; /* check "version" */ if (!(zf = zip_fopen(archive, "version", 0))) { sr_dbg("Not a sigrok session file: no version found."); zip_discard(archive); return SR_ERR; } ret = zip_fread(zf, s, sizeof(s) - 1); if (ret < 0) { sr_err("Failed to read version file: %s", zip_file_strerror(zf)); zip_fclose(zf); zip_discard(archive); return SR_ERR; } zip_fclose(zf); s[ret] = '\0'; version = g_ascii_strtoull(s, NULL, 10); if (version == 0 || version > 2) { sr_dbg("Cannot handle sigrok session file version %" PRIu64 ".", version); zip_discard(archive); return SR_ERR; } sr_spew("Detected sigrok session file version %" PRIu64 ".", version); /* read "metadata" */ if (zip_stat(archive, "metadata", 0, &zs) < 0) { sr_dbg("Not a valid sigrok session file."); zip_discard(archive); return SR_ERR; } zip_discard(archive); return SR_OK; }
char *get_contents_zip(const char *path, const char *name, time_t *last_modified) { zip_t *archive = zip_open(path, ZIP_RDONLY, NULL); if (archive == NULL) { char buffer[1024]; snprintf(buffer, 1024, "Could not open %s\n", path); engine_print(buffer); return NULL; } zip_stat_t stat; if (zip_stat(archive, name, 0, &stat) < 0) { goto close_archive; } zip_file_t *f = zip_fopen(archive, name, 0); if (f == NULL) { print_zip_err("zip_fopen", archive); goto close_archive; } if (last_modified != NULL) { *last_modified = stat.mtime; } char *buf = malloc(stat.size + 1); if (!buf) { engine_println("zip malloc"); goto close_f; } if (zip_fread(f, buf, stat.size) < 0) { print_zip_err("zip_fread", archive); goto free_buf; } buf[stat.size] = '\0'; zip_fclose(f); zip_close(archive); return buf; free_buf: free(buf); close_f: zip_fclose(f); close_archive: zip_close(archive); return NULL; }
void ZipByteReader::Register(size_t seqId, const std::string& path) { auto zipFile = m_zips.pop_or_create([this]() { return OpenZip(); }); zip_stat_t stat; zip_stat_init(&stat); int err = zip_stat(zipFile.get(), path.c_str(), 0, &stat); if (ZIP_ER_OK != err) RuntimeError("Failed to get file info of %s, zip library error: %s", path.c_str(), GetZipError(err).c_str()); m_seqIdToIndex[seqId] = std::make_pair(stat.index, stat.size); m_zips.push(std::move(zipFile)); }
bool ZIPProvider::ZIPHandle::isDir(const FileName & directory) { if (directory.getDir().empty()) { // Always return true for the root archive directory. return true; } struct zip_stat sb; zip_stat_init(&sb); if (zip_stat(handle, directory.getDir().c_str(), 0, &sb) == -1) { return false; } std::string entry(sb.name); return (entry.back() == '/' && sb.size == 0); }
bool KaraokePlayable_ZIP::extract(const QString &object, QIODevice *out) { // Retrieve the file size struct zip_stat fileinfo; // http://www.nih.at/libzip/zip_stat.html if ( zip_stat( m_zip, object.toUtf8().constData(), 0, &fileinfo) != 0 ) { m_errorMsg = zip_strerror( m_zip ); return false; } // Make sure the size field is valid if ( (fileinfo.valid & ZIP_STAT_SIZE) == 0 || (fileinfo.valid & ZIP_STAT_INDEX) == 0 ) { m_errorMsg = "not a valid file"; return false; } // Open the file struct zip_file * zgh = zip_fopen_index( m_zip, fileinfo.index, 0 ); if ( !zgh ) { m_errorMsg = "cannot open zip file"; return false; } // Extract the content char buf[32768]; unsigned int offset = 0; while ( offset < fileinfo.size ) { int toread = qMin( (qint64) sizeof(buf), (qint64) fileinfo.size - offset ); int ret = zip_fread( zgh, buf, toread ); if ( ret != toread ) { m_errorMsg = "extraction failed"; zip_fclose( zgh ); return false; } out->write( buf, ret ); offset += ret; } zip_fclose( zgh ); return true; }
/** @private */ SR_PRIV int sr_sessionfile_check(const char *filename) { struct stat st; struct zip *archive; struct zip_file *zf; struct zip_stat zs; int version, ret; char s[11]; if (!filename) return SR_ERR_ARG; if (stat(filename, &st) == -1) { sr_err("Couldn't stat %s: %s", filename, g_strerror(errno)); return SR_ERR; } if (!(archive = zip_open(filename, 0, &ret))) /* No logging: this can be used just to check if it's * a sigrok session file or not. */ return SR_ERR; /* check "version" */ if (!(zf = zip_fopen(archive, "version", 0))) { sr_dbg("Not a sigrok session file: no version found."); return SR_ERR; } if ((ret = zip_fread(zf, s, 10)) == -1) return SR_ERR; zip_fclose(zf); s[ret] = 0; version = strtoull(s, NULL, 10); if (version > 2) { sr_dbg("Cannot handle sigrok session file version %d.", version); return SR_ERR; } sr_spew("Detected sigrok session file version %d.", version); /* read "metadata" */ if (zip_stat(archive, "metadata", 0, &zs) == -1) { sr_dbg("Not a valid sigrok session file."); return SR_ERR; } if ((ret = zip_close(archive)) == -1) { sr_dbg("error closing zipfile: %s", zip_strerror(archive)); return SR_ERR; } return SR_OK; }
static int S_archive_stat(lua_State* L) { struct zip** ar = check_archive(L, 1); const char* path = (lua_isnumber(L, 2)) ? NULL : luaL_checkstring(L, 2); int path_idx = (lua_isnumber(L, 2)) ? luaL_checkint(L, 2)-1 : -1; int flags = (lua_gettop(L) < 3) ? 0 : luaL_checkint(L, 3); struct zip_stat stat; int result; if ( ! *ar ) return 0; if ( NULL == path ) { result = zip_stat_index(*ar, path_idx, flags, &stat); } else { result = zip_stat(*ar, path, flags, &stat); } if ( result != 0 ) { lua_pushnil(L); lua_pushstring(L, zip_strerror(*ar)); return 2; } lua_createtable(L, 0, 8); lua_pushstring(L, stat.name); lua_setfield(L, -2, "name"); lua_pushinteger(L, stat.index+1); lua_setfield(L, -2, "index"); lua_pushnumber(L, stat.crc); lua_setfield(L, -2, "crc"); lua_pushnumber(L, stat.size); lua_setfield(L, -2, "size"); lua_pushnumber(L, stat.mtime); lua_setfield(L, -2, "mtime"); lua_pushnumber(L, stat.comp_size); lua_setfield(L, -2, "comp_size"); lua_pushnumber(L, stat.comp_method); lua_setfield(L, -2, "comp_method"); lua_pushnumber(L, stat.encryption_method); lua_setfield(L, -2, "encryption_method"); return 1; }
struct VFile* _vdzOpenFile(struct VDir* vd, const char* path, int mode) { UNUSED(mode); // TODO: support truncating, appending and creating, and write struct VDirZip* vdz = (struct VDirZip*) vd; if ((mode & O_RDWR) == O_RDWR) { // libzip doesn't allow for random access, so read/write is impossible without // reading the entire file first. This approach will be supported eventually. return 0; } if (mode & O_WRONLY) { // Write support is not yet implemented. return 0; } struct zip_stat s; if (zip_stat(vdz->z, path, 0, &s) < 0) { return 0; } struct zip_file* zf = zip_fopen(vdz->z, path, 0); if (!zf) { return 0; } struct VFileZip* vfz = malloc(sizeof(struct VFileZip)); vfz->zf = zf; vfz->buffer = 0; vfz->offset = 0; vfz->bufferSize = 0; vfz->readSize = 0; vfz->fileSize = s.size; vfz->d.close = _vfzClose; vfz->d.seek = _vfzSeek; vfz->d.read = _vfzRead; vfz->d.readline = VFileReadline; vfz->d.write = _vfzWrite; vfz->d.map = _vfzMap; vfz->d.unmap = _vfzUnmap; vfz->d.truncate = _vfzTruncate; vfz->d.size = _vfzSize; vfz->d.sync = _vfzSync; return &vfz->d; }
uint8_t *ReadFromZip(zip *archive, const char* filename, size_t *size) { // Figure out the file size first. struct zip_stat zstat; zip_file *file = zip_fopen(archive, filename, ZIP_FL_NOCASE|ZIP_FL_UNCHANGED); if (!file) { ELOG("Error opening %s from ZIP", filename); return 0; } zip_stat(archive, filename, ZIP_FL_NOCASE|ZIP_FL_UNCHANGED, &zstat); uint8_t *contents = new uint8_t[zstat.size + 1]; zip_fread(file, contents, zstat.size); zip_fclose(file); contents[zstat.size] = 0; *size = zstat.size; return contents; }
char *get_contents_zip(char *path, char *name, time_t *last_modified) { zip_t *archive = zip_open(path, ZIP_RDONLY, NULL); if (archive == NULL) { print_zip_err("zip_open", archive); return NULL; } zip_stat_t stat; if (zip_stat(archive, name, 0, &stat) < 0) { print_zip_err("zip_stat", archive); goto close_archive; } zip_file_t *f = zip_fopen(archive, name, 0); if (f == NULL) { print_zip_err("zip_fopen", archive); goto close_archive; } if (last_modified != NULL) { *last_modified = stat.mtime; } char *buf = malloc(stat.size + 1); if (zip_fread(f, buf, stat.size) < 0) { print_zip_err("zip_fread", archive); goto free_buf; } buf[stat.size] = '\0'; zip_fclose(f); zip_close(archive); return buf; free_buf: free(buf); zip_fclose(f); close_archive: zip_close(archive); return NULL; }
size_t fs_file_size(const char *filename) { if (is_cwd_zip()) { struct directory *d; struct zip_stat sb; char buf[NAME_MAX]; d = sf_list_tail(&fs.directories); get_zip_cwd(buf, NAME_MAX); strcat(buf, filename); zip_stat(d->zip, buf, 0, &sb); return sb.size; } else { struct stat sb; stat(filename, &sb); return sb.st_size; } }
wxImage ZipEntry::LoadImage() { mutex->Lock(); if (IsDirectory()) return wxImage(); struct zip_stat stat; zip_stat(zipFile, innerPath, 0, &stat); auto file = zip_fopen(zipFile, innerPath, 0); auto size = stat.size; auto buffer = new unsigned char[size]; auto read = zip_fread(file, buffer, size); wxMemoryInputStream stream(buffer, size); wxImage output(stream); delete[] buffer; mutex->Unlock(); return output; }
bool ZipAssetReader::GetFileInfo(const char *path, FileInfo *info) { struct zip_stat zstat; char temp_path[1024]; strcpy(temp_path, in_zip_path_); strcat(temp_path, path); if (0 != zip_stat(zip_file_, temp_path, ZIP_FL_NOCASE, &zstat)) { // ZIP files do not have real directories, so we'll end up here if we // try to stat one. For now that's fine. info->exists = false; info->size = 0; return false; } info->fullName = path; info->exists = true; // TODO info->isWritable = false; info->isDirectory = false; // TODO info->size = zstat.size; return true; }
//------------------------------------------------------------------------------------------------------- void Unpack::Decompress(const std::string& from, const std::string& to) { struct zip_stat zs; zip_stat(m_pAPKArchive, from.c_str(), ZIP_FL_UNCHANGED , &zs);//读取zip属性 DEBUGLOG("%s size is %d ", from.c_str(), zs.size); byte* data = NEW byte[zs.size]; zip_file* zipfile; zipfile = zip_fopen(m_pAPKArchive, from.c_str(), 0); //打开文件流 zip_fread(zipfile, data, zs.size); //读取文件 DEBUGLOG("save to %s", to.c_str()); FilePtr writeto; File::Instance().OpenFile(to.c_str(), File::FILE_WRITE, writeto); File::Instance().WriteFile(data, zs.size, 1, writeto); File::Instance().CloseFile(writeto); zip_fclose(zipfile);//关闭文件 }
/************************************************* Function: readDexFile Descroption: Input: 1.zip* z 2.filename 3.char* buf Output: Return: Other: *************************************************/ long readDexFile(struct zip* z, char* filename, unsigned char** buf) { int i; long ReadNum = 0; struct zip_stat fstat; if(z != NULL && NULL != buf) { zip_stat_init(&fstat); int c = zip_get_num_files(z); if(c > 0) { for (i = 0 ; i < c; i++) { const char* name = zip_get_name(z, i, 0); if(0 == strcmp(name,filename)) { zip_stat(z, name,0,&fstat); //LOGI("File %i:%s Size1: %lld Size2: %lld\n", i,fstat.name,fstat.size ,fstat.comp_size); struct zip_file* file = zip_fopen(z, filename, 0); if (file) { *buf =(unsigned char *)malloc(fstat.size+1); memset(*buf,0,(fstat.size+1)); ReadNum = zip_fread(file, *buf,fstat.size); zip_fclose(file); } break; } } } } else { return 0; } return ReadNum; }
static VALUE zipruby_stat_initialize(int argc, VALUE *argv, VALUE self) { VALUE archive, index, flags; struct zipruby_archive *p_archive; struct zipruby_stat *p_stat; char *fname = NULL; int i_index = -1, i_flags = 0; rb_scan_args(argc, argv, "21", &archive, &index, &flags); if (!rb_obj_is_instance_of(archive, Archive)) { rb_raise(rb_eTypeError, "wrong argument type %s (expected ZipRuby::Archive)", rb_class2name(CLASS_OF(archive))); } switch (TYPE(index)) { case T_STRING: fname = RSTRING_PTR(index); break; case T_FIXNUM: i_index = NUM2INT(index); break; default: rb_raise(rb_eTypeError, "wrong argument type %s (expected String or Fixnum)", rb_class2name(CLASS_OF(index))); } if (!NIL_P(flags)) { i_flags = NUM2INT(flags); } Data_Get_Struct(archive, struct zipruby_archive, p_archive); Check_Archive(p_archive); Data_Get_Struct(self, struct zipruby_stat, p_stat); if (fname) { if (zip_stat(p_archive->archive, fname, i_flags, p_stat->sb) != 0) { rb_raise(Error, "Obtain file status failed - %s: %s", fname, zip_strerror(p_archive->archive)); } } else { if (zip_stat_index(p_archive->archive, i_index, i_flags, p_stat->sb) != 0) { rb_raise(Error, "Obtain file status failed at %d: %s", i_index, zip_strerror(p_archive->archive)); } } return Qnil; }
bool ZipFileManager::GetFileBuffer(const str_type::string &fileName, FileBuffer &out) { if (!IsLoaded()) return false; str_type::string fixedPath = fileName; FixSlashesForUnix(fixedPath); zip_file *file = zip_fopen(m_archive, fixedPath.c_str(), 0); if (file == NULL) return false; struct zip_stat stat; zip_stat(m_archive, fixedPath.c_str(), 0, &stat); out = FileBuffer(new _FileBuffer<unsigned char>(static_cast<unsigned long>(stat.size))); zip_fread(file, out->GetAddress(), stat.size); zip_fclose(file); return true; }
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) { struct zip_stat zs; struct session_vdev *vdev; int ret; vdev = sdi->priv; sr_info("Opening archive %s file %s", vdev->sessionfile, vdev->capturefile); if (!(vdev->archive = zip_open(vdev->sessionfile, 0, &ret))) { sr_err("Failed to open session file '%s': " "zip error %d\n", vdev->sessionfile, ret); return SR_ERR; } if (zip_stat(vdev->archive, vdev->capturefile, 0, &zs) == -1) { sr_err("Failed to check capture file '%s' in " "session file '%s'.", vdev->capturefile, vdev->sessionfile); return SR_ERR; } if (!(vdev->capfile = zip_fopen(vdev->archive, vdev->capturefile, 0))) { sr_err("Failed to open capture file '%s' in " "session file '%s'.", vdev->capturefile, vdev->sessionfile); return SR_ERR; } /* Send header packet to the session bus. */ std_session_send_df_header(sdi, LOG_PREFIX); /* freewheeling source */ sr_session_source_add(-1, 0, 0, receive_data, sdi); return SR_OK; }
void ZipFileOutput::dumpFile() { if(m_currentFile) { m_bufferedFiles.push_back(m_currentFile->str()); std::string & fileContent = m_bufferedFiles.back(); zip_source* source = zip_source_buffer(m_archiveHandle, fileContent.c_str(), fileContent.size(), 0); if(! source) throw FileAccessFailed(m_currentFilename, m_archive, "Failed to allocate ZLib source."); // check if the file exists struct zip_stat stat; if(zip_stat(m_archiveHandle, m_currentFilename.c_str(), 0, &stat) < 0) { // the file does not exist // add it to the archive if(zip_add(m_archiveHandle, m_currentFilename.c_str(), source) < 0) { zip_source_free(source); throw FileAccessFailed(m_currentFilename, m_archive, "Failed to add file to zip archive."); } } else { // the file exists // replace it in the archive if(zip_replace(m_archiveHandle, stat.index, source) < 0) { zip_source_free(source); throw FileAccessFailed(m_currentFilename, m_archive, "Failed to replace file in zip archive."); } } delete m_currentFile; m_currentFile = 0; } }
std::istream& ZipFileInput::openFile(const stromx::runtime::InputProvider::OpenMode mode) { if(! m_initialized) throw WrongState("Zip file input has not been initialized."); if(m_currentFile) throw WrongState("File has already been opened."); if(! hasFile()) throw NoInputFile(); std::ios_base::openmode iosmode = std::ios_base::in; if(mode == BINARY) iosmode |= std::ios_base::binary; struct zip_stat stat; if(zip_stat(m_archiveHandle, m_currentFilename.c_str(), 0, &stat) < 0) throw FileAccessFailed(m_currentFilename, m_archive, "Failed to access file in zip archive."); if(stat.size == 0) throw FileAccessFailed(m_currentFilename, m_archive, "File in zip archive has zero size."); unsigned int fileSize = (unsigned int)(stat.size); std::vector<char> content(fileSize); zip_file* file = zip_fopen(m_archiveHandle, m_currentFilename.c_str(), 0); if(! file) throw FileAccessFailed(m_currentFilename, m_archive, "Failed to open file in zip archive."); if((unsigned int)(zip_fread(file, &content[0], fileSize)) != fileSize) throw FileAccessFailed(m_currentFilename, m_archive, "Failed to read file in zip archive."); m_currentFile = new std::istringstream(std::string(&content[0], fileSize), iosmode); return *m_currentFile; }
int main(int argc, char* argv[]) { // Single byte to be read from the data files char c; // Counters to keep track of cuts unsigned long waveformCtr = 0; unsigned long linearGateCtr = 0; unsigned long muonVetoCtr = 0; unsigned long overflowCtr = 0; unsigned long bgAnalysisCtr = 0; unsigned long sAnalysisCtr = 0; // Variables for the background output files int bg_counter = 0; int bg_file_number = 0; std::ofstream bg_out_file; // Variables for the signal output files int s_counter = 0; int s_file_number = 0; std::ofstream s_out_file; // Run Info output std::ofstream infoOut; // Saved waveforms std::ofstream waveformOut; // LabView headers int no_samples = 0; int no_channels = 0; // Timestamp of current trigger std::string timestamp; // Waveform buffers int csi [35000] = {} ; int csi_raw[35000] = {} ; int mv [35000] = {} ; // Buffer to store bit shifted samples int _tmpC = 0; // Medians of CsI and muon veto int med_csi = 0; int med_mv = 0; // Buffers used for median calculation as well as overflow detection unsigned int med_csi_sum = 0; unsigned int med_mv_sum = 0; unsigned int med_csi_arr [256] = {} ; unsigned int med_mv_arr [256] = {}; bool med_csi_found = false; bool med_mv_found = false; bool overflow = false; // Buffers for SPE integration int spe_charge_dist[300] = {}; int spe_integration_ctr = 0; int spe_integration_charge = 0; // Buffers for peaks in pretrace int bg_pe_pt[52] = {}; int s_pe_pt[52] = {}; // Buffer for baseline int baseline_hist[32] = {}; // Rising and falling threshold crossings used for linear gate detection int _previous_c = 0; int gate_down = 0; int gate_up = 0; // Waveform contains a gate or muon veto fired more than three times bool linear_gate = false; bool muon_veto_flag = false; // Photoelectron counter for all interesting regions // pt = pretrace, roi = region of interest, iw = integration window unsigned int s_pt_ct = 0; unsigned int bg_pt_ct = 0; unsigned int s_roi_ct = 0; unsigned int bg_roi_ct = 0; unsigned int s_iw_ct = 0; unsigned int bg_iw_ct = 0; unsigned int PE_max_PT = 10; // Buffers to store current peak width in CsI and muon veto waveform int above_pe_threshold = 0; int current_peak_width = 0; int current_pe_width = 0; int m_peak_width = 0; // Peak thresholds int peak_height_threshold = 3; int peak_width_threshold = 4; // Peak locations in CsI, Muon locations in muon veto std::vector<int> peaks; std::vector<int> peak_heights; int peak_height_dist[100] = {}; int peak_amplitude = 0; std::vector<int> pe_beginnings; std::vector<int> pe_endings; std::vector<int> muon_peaks; std::vector<int> muon_onset_arr; // Keep track of all peak/pe locations in the full minute int peak_distribution[350][350] = {}; int charge_distribution[350][350] = {}; for (int i1 = 0; i1 < 350; i1++) { for (int i2 = 0; i2 < 350; i2++) { peak_distribution[i1][i2] = 0; charge_distribution[i1][i2] = 0; } } // Get peak width distribution int peak_width_distribution[51] = {}; // Charge of PE in PT int current_spe_q = 0; // Integration window buffers int s_q_arr [1500] = {}; int bg_q_arr [1500] = {}; int running_charge = 0; // LogLikelihood prefactors & estimators double lnL_pf_real[1500] = {}; double lnL_pf_flat[1500] = {}; double lnL_real = 0; double lnL_flat = 0; // Big pulse detection bool bP_detected = false; int _t_bP_idx = 0; std::vector<int> bP_onset_arr; std::vector<int> bP_charge_arr; // Calculate prefactors for loglikelihood analysis // timing and fraction from NIMA paper double r = 0.41; double tf = 527.0; double ts = 5600.0; // total integration window is 3 us long -> tMax = 1500 double _tFast = 1.0 / ((1.0 + r) * tf * (1 - exp(-1500.0 / tf))); double _tSlow = r / ((1.0 + r) * ts * (1 - exp(-1500.0 / ts))); // Calculate prefactor for each time step for (int i = 0; i < 1500; i++) { lnL_pf_real[i] = log(_tFast * exp(-(double)i / tf) + _tSlow * exp(-(double)i / ts)); lnL_pf_flat[i] = log(1.0 / 1500.0); } // Threshold buffer and measured rise times double thresholds [3] = {}; double bg_rt [3] = {}; double s_rt [3] = {}; // Buffers used during window analysis int idx_0 = 0; int idx_w_offset = 0; int i_peak = 0; int i_pe = 0; int q_int = 0; double _t1 = 0.0; double _t2 = 0.0; std::string main_dir; int current_time; int single_time; std::string out_dir; std::string current_zip_file; std::string time_name_in_zip; // Save waveforms as ascii - Counter,cuts etc int save_wf_ctr = 0; int no_total_peaks[2] = { 100, 200 }; int minimum_no_peaks_iw = 6; int rt1090_bottom_left[2] = { 750, 1150 }; int rt050_bottom_left[2] = { 235, 345 }; int rt1090_upper_right[2] = { 1080, 1280 }; int rt050_upper_right[2] = { 520, 760 }; bool save_waveforms = false; bool passed_cuts_bg = false; bool passed_cuts_s = false; bool passed_cut = false; // Set main run directory, e.g. Run-15-10-02-27-32-23/151002 // Set current time to be analzyed as index of sorted number of total files in folder, e.g. 0-1439 for a full day // Set output directory, eg Output/ Run-15-10-02-27-32-23/151002 int data_set = 0; if (argc == 6) { data_set = atoi(argv[1]); main_dir = std::string(argv[2]); current_time = atoi(argv[3]); out_dir = std::string(argv[4]); single_time = atoi(argv[5]); } else { std::cout << "Arguments not matching! Aborting now!" << std::endl; return 1; } unsigned int BG_PT[2] = {}; unsigned int BG_ROI[2] = {}; unsigned int S_PT[2] = {}; unsigned int S_ROI[2] = {}; switch (data_set) { case 1: BG_PT[0] = 0; BG_PT[1] = 19975; BG_ROI[0] = 19975; BG_ROI[1] = 27475; S_PT[0] = 7500; S_PT[1] = 27475; S_ROI[0] = 27475; S_ROI[1] = 34975; PE_max_PT = 10; break; case 2: BG_PT[0] = 0; BG_PT[1] = 20000; BG_ROI[0] = 20000; BG_ROI[1] = 27400; S_PT[0] = 7400; S_PT[1] = 27400; S_ROI[0] = 27400; S_ROI[1] = 35000; PE_max_PT = 20; break; case 3: BG_PT[0] = 0; BG_PT[1] = 17500; BG_ROI[0] = 17500; BG_ROI[1] = 25000; S_PT[0] = 7500; S_PT[1] = 25000; S_ROI[0] = 25000; S_ROI[1] = 32500; PE_max_PT = 30; break; default: std::cout << "Arguments not matching! Aborting now!" << std::endl; return 1; } // Full analysis -> Converts $(Process) from condor submit to the current time file if (single_time == 0) { // Buffers used to process data files and to step through directories std::vector<std::string> time_files; DIR *dpdf; struct dirent *epdf; // Find all time files and sort them time_files.clear(); dpdf = opendir(main_dir.c_str()); if (dpdf != NULL) { std::string _tmp; while (epdf = readdir(dpdf)) { _tmp = epdf->d_name; if (_tmp != "." && _tmp != ".." && _tmp.substr(7) == "zip") { time_files.push_back(_tmp.substr(0, 6)); } } } // Sort time files by time in ascending order to convert current_time index to proper file std::sort(time_files.begin(), time_files.end(), timeSort); // Prepare paths to zipped and unzipped files current_zip_file = main_dir + "/" + time_files[current_time] + ".zip"; time_name_in_zip = time_files[current_time]; } // Single file analysis -> Directly convert input to current time file else { current_zip_file = main_dir + "/" + zeroPad(current_time,6) +".zip"; time_name_in_zip = zeroPad(current_time,6); } //Open the ZIP archive int err = 0; int zidx = 0; int fileSize = 0; zip *z = zip_open(current_zip_file.c_str(), 0, &err); //Search for the file of given name const char *name = time_name_in_zip.c_str(); struct zip_stat st; zip_stat_init(&st); zip_stat(z, name, 0, &st); //Alloc memory for its uncompressed contents char *contents = new char[st.size]; // Unzip the compressed file into memory zip_file *f = zip_fopen(z, time_name_in_zip.c_str(), 0); fileSize = st.size; zip_fread(f, contents, fileSize); zip_fclose(f); //And close the archive zip_close(z); // Create signal, background and info output files bg_out_file.open((out_dir + "/" + fileName(atoi(time_name_in_zip.c_str()), "B-")).c_str(), std::ofstream::out | std::ofstream::trunc); s_out_file.open((out_dir + "/" + fileName(atoi(time_name_in_zip.c_str()), "S-")).c_str(), std::ofstream::out | std::ofstream::trunc); infoOut.open((out_dir + "/" + fileName(atoi(time_name_in_zip.c_str()), "I-")).c_str(), std::ofstream::out | std::ofstream::trunc); if (save_waveforms) { waveformOut.open((out_dir + "/" + fileName(atoi(time_name_in_zip.c_str()), "W-")).c_str(), std::ofstream::out | std::ofstream::trunc); } // Begin data processing if file has been properly opened if(err == 0) { waveformCtr = 0; zidx = 0; // Begin reading byte-stream while (zidx < fileSize) { // Read LabView header and get the total number of samples written for each channel in the next chunk of data for (int i=0;i<4;i++) { c = contents[zidx++]; no_samples = no_samples << 8 | (unsigned char) c; } // Read LabView header and get the total number of channels written in next chunk of data (always 2 in our case) for (int i=0;i<4;i++) { c = contents[zidx++]; no_channels = no_channels << 8 | (unsigned char) c; } // Takes care of LabViews closing bit... if (no_samples > 350070) { break; } // ---------------------------------------------------------------- // Process XYZ consecutive waveforms without encountering another // LabView header inbetween // ---------------------------------------------------------------- for (int wf=0; wf < (int) (no_samples/35007); wf++) { // A new waveform begins waveformCtr += 1; // ------------------------------------------------------------- // Reset all major waveform specific variables // ------------------------------------------------------------- timestamp.clear(); overflow = false; linear_gate = false; muon_veto_flag = false; _previous_c = 128; gate_down = 0; gate_up = 0; memset(med_csi_arr,0,sizeof med_csi_arr); memset(med_mv_arr,0,sizeof med_mv_arr ); med_csi_found = false; med_mv_found = false; med_csi_sum = 0; med_mv_sum = 0; above_pe_threshold = 0; current_peak_width = 0; current_pe_width = 0; current_spe_q = 0; m_peak_width = 0; peaks.clear(); peak_heights.clear(); pe_beginnings.clear(); pe_endings.clear(); muon_peaks.clear(); spe_integration_ctr = 0; spe_integration_charge = 0; passed_cuts_s = false; passed_cuts_bg = false; passed_cut = false; peak_amplitude = 0; bP_detected = false; _t_bP_idx = 0; // ------------------------------------------------------------- // Read current timestamp // ------------------------------------------------------------- for(int i=0; i<7; i++) { c = contents[zidx++]; c = contents[zidx++]; timestamp += zeroPad((int) c, 2); } // --------------------------------------------------------------- // Read the full CsI and muon veto waveforms from the zip-stream // + Apply bit transformation // + Determine if a linear gate is present // --------------------------------------------------------------- for(int i=0; i<35000; i++) { //-------------- // CsI //-------------- c = contents[zidx++]; // bit transformation to get rid of empty bins _tmpC = (int) c - (int) floor(((double) c + 5.0)/11.0); if (i<20000){ med_csi_arr[_tmpC + 128] += 1; } csi[i] = _tmpC; csi_raw[i] = _tmpC; if (i == 0) { _previous_c = _tmpC; } // Gate check if (_tmpC <= 18 && _previous_c > 18) { gate_down++; } if (_previous_c <= 18 && _tmpC > 18) { gate_up++; } _previous_c = _tmpC; // Overflow check if (!overflow && (c >= 127 || c == -128)) { overflow = true; overflowCtr += 1; } //-------------- // Muon Veto //-------------- c = contents[zidx++]; _tmpC = (int) c + (int) ((signbit((int) c) ? -1 : 1 ) * floor((4.0 - abs((double) c))/11.0)); med_mv_arr[_tmpC + 128] += 1; mv[i] = _tmpC; } // --------------------------------------- // Calculate the median of both channels // --------------------------------------- for(int i=0; i<256; i++) { if (!med_csi_found) { med_csi_sum += med_csi_arr[i]; if (med_csi_sum >= 10000) { med_csi = i-128; med_csi_found=true; } } if (!med_mv_found) { med_mv_sum += med_mv_arr[i]; if (med_mv_sum >= 10000) { med_mv = i-128; med_mv_found=true; } } } // ---------------------------------------------- // Adjust linear gate counter if wf is gated // ---------------------------------------------- if (gate_down != gate_up || med_csi < 50) { linear_gate = true; linearGateCtr += 1; } // ----------------------------------------------- // Find peaks and photoelectrons in waveforms // ----------------------------------------------- current_peak_width = 0; peak_amplitude = 0; bP_detected = false; for (int i = 0; i < 35000; i++) { // ------------------------------------------- // Analyze CsI[Na] waveform // ------------------------------------------- csi[i] = med_csi - csi[i]; // Simple peak finder using threshold crossing with history if (csi[i] >= peak_height_threshold) { current_peak_width++; peak_amplitude = csi[i] > peak_amplitude ? csi[i] : peak_amplitude; } else { if (current_peak_width >= peak_width_threshold) { peaks.push_back(i - current_peak_width); pe_beginnings.push_back((i - current_peak_width - 2) >= 0 ? (i - current_peak_width - 2) : 0); pe_endings.push_back((i + 1) <= 34999 ? (i + 1) : 34999); peak_width_distribution[(current_peak_width < 50) ? current_peak_width : 50] += 1; peak_heights.push_back(peak_amplitude); // Check for large energy depositions if (!bP_detected && current_peak_width >= 35 && !linear_gate && !overflow) { bP_detected = true; bP_onset_arr.push_back(i - current_peak_width); } } current_peak_width = 0; peak_amplitude = 0; } // ------------------------------------------- // Analyze muon veto waveform // ------------------------------------------- mv[i] = med_mv - mv[i]; // Peak finder if (mv[i] >= 10) { m_peak_width++; } else { if (m_peak_width >= 3) { muon_peaks.push_back(i-m_peak_width); } m_peak_width = 0; } } // If there was a big pulse in the trace integrate it // But only if there was no linear gate or overflow if (bP_detected && !linear_gate && !overflow) { int _t_charge = 0; for (int i = bP_onset_arr.back(); i < (1500 + bP_onset_arr.back()); i++) { _t_charge += (csi[i] >= peak_height_threshold) ? csi[i] : 0; } bP_charge_arr.push_back(_t_charge); } // Raise muon veto flag if more than three muons have been found // If less than 3 have been found fill the vector with -1 for postprocessing int muons_found = muon_peaks.size(); if (muons_found > 0) { if (linear_gate) { muon_onset_arr.push_back(muon_peaks[0]); } else { for (std::vector<int>::size_type idx = 0; idx < muons_found; idx++) { muon_onset_arr.push_back(muon_peaks[idx]); } } } if (muons_found > 3) { muon_veto_flag = true; muonVetoCtr += 1; } else { muon_peaks.resize(3, -1); } // Add PE peaks to peak height distribution if (peak_heights.size() > 0 && !overflow && !linear_gate) { for (int idx = 0; idx < peak_heights.size(); idx++) { peak_height_dist[(peak_heights[idx] < 100) ? peak_heights[idx] : 99]++; } } // ======================================================================== // Check that there is at least one PE in the trace, there is no overflow, // no linear gate and no muon veto flag, otherwise continue to next // waveform without bothering to analyze this one // ======================================================================== bool analyze = false; if (data_set == 1 && !overflow && !linear_gate && !muon_veto_flag) { analyze = true; } if (data_set == 2 && !overflow && !linear_gate) { analyze = true; } if (data_set == 3 && !overflow && !linear_gate) { analyze = true; } if (analyze && pe_beginnings.size() > 0) { // ------------------------------------------------------------- // Integrate all SPE found in the PT and histogram their charge // ------------------------------------------------------------- for (std::vector<int>::size_type idx = 0; idx < pe_beginnings.size(); idx++) { if (pe_beginnings[idx] < BG_PT[1]) { current_spe_q = 0; for (int i = pe_beginnings[idx]; i <= pe_endings[idx]; i++) { current_spe_q += csi[i]; } if (current_spe_q >= -50 && current_spe_q < 250) { spe_charge_dist[(current_spe_q+50)] += 1; } } else { break; } } // ------------------------------------------------------------- // Determine number of PE in different regions // ------------------------------------------------------------- bg_pt_ct = 0; bg_roi_ct = 0; bg_iw_ct = 0; s_pt_ct = 0; s_roi_ct = 0; s_iw_ct = 0; if (peaks.size() > 0) { for (std::vector<int>::size_type idx = 0; idx < peaks.size(); idx++) { if (peaks[idx] >= BG_PT[0] && peaks[idx] < BG_PT[1]) { bg_pt_ct += 1; } if (peaks[idx] >= S_PT[0] && peaks[idx] < S_PT[1]) { s_pt_ct += 1; } if (peaks[idx] >= BG_ROI[0] && peaks[idx] < BG_ROI[1]) { bg_roi_ct += 1; } if (peaks[idx] >= S_ROI[0] && peaks[idx] < S_ROI[1]) { s_roi_ct += 1; } } // Distribution of charge (only add >= 3) if (true) { int sz = peaks.size() / 2; if (sz < 350) { int cpi = 0; for (int idx = 0; idx < 35000; idx++) { // Add sample if it is within one of the PE regions identified previously if (idx >= pe_beginnings[cpi] && idx <= pe_endings[cpi]) { charge_distribution[sz][idx / 100] += csi[idx]; if (idx >= pe_endings[cpi]) { if (++cpi >= pe_beginnings.size()){ break; } } } } } } } // Histogram baseline and peaks in pretrace if (!overflow && !linear_gate && !muon_veto_flag) { int _t_med_csi_bin = med_csi - 85; if (_t_med_csi_bin >= 0 && _t_med_csi_bin <=30) { baseline_hist[_t_med_csi_bin]++; } else { baseline_hist[31]++; } if (bg_pt_ct <= 50) { bg_pe_pt[bg_pt_ct]++; } else { bg_pe_pt[51]++; } if (s_pt_ct <= 50) { s_pe_pt[s_pt_ct]++; } else { s_pe_pt[51]++; } } // ------------------------------------------------------------- // Only analzye BG region if there are a maximum of PE_max_PT // & at least one PE in ROI // ------------------------------------------------------------- if (bg_pt_ct <= PE_max_PT && bg_roi_ct > 0) { bgAnalysisCtr += 1; // Reset window parameters idx_0 = 0; i_peak = 0; i_pe = 0; q_int = 0; lnL_real = 0.0; lnL_flat = 0.0; _t1 = 0.0; _t2 = 0.0; // ------------------------------------------------------------- // Determine onset of integration window by finding the first // PE in the region of interest // ------------------------------------------------------------- for (int i = 0; i < peaks.size(); i++) { if (peaks[i] >= BG_ROI[0]) { idx_0 = peaks[i]; i_peak = i; break; } } idx_0 -= 3; // ------------------------------------------------------------- // Only analyze if the full integration window is within the ROI // ------------------------------------------------------------- if (idx_0 < (BG_ROI[1] - 1500)) { // -------------------------------------------------------------- // Determine number of peaks in integration window (magic bullet) // -------------------------------------------------------------- for (int i = i_peak; i < peaks.size(); i++) { bg_iw_ct += (peaks[i] - idx_0 < 1500) ? 1 : 0; } // ------------------------------------------------------------- // Integrate over all PE found in the integration window // ------------------------------------------------------------- i_pe = i_peak; for (int i = 0; i < 1500; i++) { // Get proper 'real' index that includes the onset offset idx_w_offset = i + idx_0; // Add sample if it is within one of the PE regions identified previously as well as update loglikelihood estimators if (i_pe < pe_beginnings.size() && idx_w_offset >= pe_beginnings[i_pe] && idx_w_offset <= pe_endings[i_pe]) { q_int += csi[idx_w_offset]; lnL_real += lnL_pf_real[i] * csi[idx_w_offset]; lnL_flat += lnL_pf_flat[i] * csi[idx_w_offset]; if (idx_w_offset == pe_endings[i_pe]) { i_pe++; } } // Keep track of charge integration to determine rise times later bg_q_arr[i] = q_int; } // ------------------------------------------------------------- // Determine rise times // ------------------------------------------------------------- // Calculate charge thresholds thresholds[0] = 0.1*bg_q_arr[1499]; thresholds[1] = 0.5*bg_q_arr[1499]; thresholds[2] = 0.9*bg_q_arr[1499]; // Determine threshold crossing times for (int i = 0; i < 1499; i++) { _t1 = (double)bg_q_arr[i]; _t2 = (double)bg_q_arr[i + 1]; for (int j = 0; j < 3; j++) { if (_t1 < thresholds[j] && _t2 >= thresholds[j]){ bg_rt[j] = i + (thresholds[j] - _t1) / (_t2 - _t1); } } } // ------------------------------------------------------------- // If waveforms are being saved check whether cuts are passed // ------------------------------------------------------------- if (save_waveforms) { int rt1090 = (bg_rt[2] - bg_rt[0]); int rt050 = bg_rt[1]; bool bottom_left_cut = (rt1090 >= rt1090_bottom_left[0]) && (rt1090 <= rt1090_bottom_left[1]) && (rt050 >= rt050_bottom_left[0]) && (rt050 <= rt050_bottom_left[1]); bool upper_right_cut = (rt1090 >= rt1090_upper_right[0]) && (rt1090 <= rt1090_upper_right[1]) && (rt050 >= rt050_upper_right[0]) && (rt050 <= rt050_upper_right[1]); bool min_peak_cut = (bg_iw_ct >= minimum_no_peaks_iw); bool total_peak_cut = (peaks.size() >= no_total_peaks[0]) && (peaks.size() <= no_total_peaks[1]); passed_cuts_bg = (bottom_left_cut || upper_right_cut) && min_peak_cut && total_peak_cut; } // ------------------------------------------------------------- // Write analysis results to file // ------------------------------------------------------------- bg_out_file << timestamp << " " << med_csi << " " << med_mv << " "; bg_out_file << bg_pt_ct << " " << bg_roi_ct << " "; bg_out_file << bg_iw_ct << " " << idx_0 << " " << bg_q_arr[1499] << " " << lnL_real << " " << lnL_flat << " "; bg_out_file << bg_rt[0] << " " << bg_rt[1] << " " << bg_rt[2] << " "; bg_out_file << muon_peaks[0] << " " << muon_peaks[1] << " " << muon_peaks[2] << " " << peaks.size() << std::endl; // Keeps track of how many BG waveforms have actually been analyzed bg_counter++; } } // ------------------------------------------------------------- // Only analzye S region if there are a maximum of PE_max_PT // & at least one PE in ROI // ------------------------------------------------------------- if (s_pt_ct <= PE_max_PT && s_roi_ct > 0) { sAnalysisCtr += 1; // Reset window parameters idx_0 = 0; i_peak = 0; i_pe = 0; q_int = 0; lnL_real = 0.0; lnL_flat = 0.0; _t1 = 0.0; _t2 = 0.0; // ------------------------------------------------------------- // Determine onset of integration window by finding the first // PE in the region of interest // ------------------------------------------------------------- for (int i = 0; i < peaks.size(); i++) { if (peaks[i] >= S_ROI[0]) { idx_0 = peaks[i]; i_peak = i; break; } } idx_0 -= 3; // ------------------------------------------------------------- // Only analyze if the full integration window is within the ROI // ------------------------------------------------------------- if (idx_0 < (S_ROI[1] - 1500)) { // -------------------------------------------------------------- // Determine number of peaks in integration window (magic bullet) // -------------------------------------------------------------- for (int i = i_peak; i < peaks.size(); i++) { s_iw_ct += (peaks[i] - idx_0 < 1500) ? 1 : 0; } i_pe = i_peak; // ------------------------------------------------------------- // Integrate over all PE found in the integration window // ------------------------------------------------------------- for (int i = 0; i < 1500; i++) { // Get proper 'real' index that includes the onset offset idx_w_offset = i + idx_0; // Add sample if it is within one of the PE regions identified previously & update loglikelihood estimators if (i_pe < pe_beginnings.size() && idx_w_offset >= pe_beginnings[i_pe] && idx_w_offset <= pe_endings[i_pe]) { q_int += csi[idx_w_offset]; lnL_real += lnL_pf_real[i] * csi[idx_w_offset]; lnL_flat += lnL_pf_flat[i] * csi[idx_w_offset]; if (idx_w_offset == pe_endings[i_pe]) { i_pe++; } } // Keep track of charge integration to determine rise times later s_q_arr[i] = q_int; } // ------------------------------------------------------------- // Determine rise times // ------------------------------------------------------------- // Calculate charge thresholds thresholds[0] = 0.1*s_q_arr[1499]; thresholds[1] = 0.5*s_q_arr[1499]; thresholds[2] = 0.9*s_q_arr[1499]; // Determine threshold crossing times for (int i = 0; i < 1499; i++) { _t1 = (double)s_q_arr[i]; _t2 = (double)s_q_arr[i + 1]; for (int j = 0; j < 3; j++) { if (_t1 < thresholds[j] && _t2 >= thresholds[j]){ s_rt[j] = i + (thresholds[j] - _t1) / (_t2 - _t1); } } } // ------------------------------------------------------------- // If waveforms are being saved check whether cuts are passed // ------------------------------------------------------------- if (save_waveforms) { int rt1090 = (s_rt[2] - s_rt[0]); int rt050 = s_rt[1]; bool bottom_left_cut = (rt1090 >= rt1090_bottom_left[0]) && (rt1090 <= rt1090_bottom_left[1]) && (rt050 >= rt050_bottom_left[0]) && (rt050 <= rt050_bottom_left[1]); bool upper_right_cut = (rt1090 >= rt1090_upper_right[0]) && (rt1090 <= rt1090_upper_right[1]) && (rt050 >= rt050_upper_right[0]) && (rt050 <= rt050_upper_right[1]); bool min_peak_cut = (s_iw_ct >= minimum_no_peaks_iw); bool total_peak_cut = (peaks.size() >= no_total_peaks[0]) && (peaks.size() <= no_total_peaks[1]); passed_cuts_s = (bottom_left_cut || upper_right_cut) && min_peak_cut && total_peak_cut; } // ------------------------------------------------------------- // Write analysis results to file // ------------------------------------------------------------- s_out_file << timestamp << " " << med_csi << " " << med_mv << " "; s_out_file << s_pt_ct << " " << s_roi_ct << " "; s_out_file << s_iw_ct << " " << idx_0 << " " << s_q_arr[1499] << " " << lnL_real << " " << lnL_flat << " "; s_out_file << s_rt[0] << " " << s_rt[1] << " " << s_rt[2] << " "; s_out_file << muon_peaks[0] << " " << muon_peaks[1] << " " << muon_peaks[2] << " " << peaks.size() << std::endl; // Keeps track of how many BG waveforms have actually been analyzed s_counter++; } } } // ------------------------------------------------------------- // Save waveform if cuts have been passed for either ROI // ------------------------------------------------------------- if (save_waveforms && passed_cut) { for (int idx = 0; idx < 35000; idx++) { waveformOut << csi_raw[idx] << " "; } waveformOut << gate_up << " " << gate_down << " " << med_csi << " "; for (int idx = 0; idx < pe_beginnings.size(); idx++) { waveformOut << pe_beginnings[idx] << " " << pe_endings[idx] << " "; } waveformOut << std::endl; } } } } // Before exiting, make sure that both output files are properly closed to prevent data loss. if (bg_out_file.is_open()) { bg_out_file.close(); } if (s_out_file.is_open()) { s_out_file.close(); } // Write run info if (infoOut.is_open()) { infoOut << "Total number of Waveforms processed" << std::endl; infoOut << waveformCtr << std::endl; infoOut << "Number of triggers with linear gates in CsI channel" << std::endl; infoOut << linearGateCtr << std::endl; infoOut << "Number of triggers with overflows in either channel" << std::endl; infoOut << overflowCtr << std::endl; infoOut << "Number of triggers with more than 3 muons in muon veto channel" << std::endl; infoOut << muonVetoCtr << std::endl; infoOut << "Number of triggers that have actually been analyzed in the background window (less than x PE/peaks in PT + at least one PE/peak in ROI)" << std::endl; infoOut << bgAnalysisCtr << std::endl; infoOut << "Number of triggers that have actually been analyzed in the signal window (less than x PE/peaks in PT + at least one PE/peak in ROI)" << std::endl; infoOut << sAnalysisCtr << std::endl; infoOut << "Maximum number of PE/peaks in the pretrace" << std::endl; infoOut << PE_max_PT << std::endl; infoOut << "Background pretrace start" << std::endl; infoOut << BG_PT[0] << std::endl; infoOut << "Background pretrace stop" << std::endl; infoOut << BG_PT[1] << std::endl; infoOut << "Background ROI start" << std::endl; infoOut << BG_ROI[0] << std::endl; infoOut << "Background ROI stop" << std::endl; infoOut << BG_ROI[1] << std::endl; infoOut << "Signal pretrace start" << std::endl; infoOut << S_PT[0] << std::endl; infoOut << "Signal pretrace stop" << std::endl; infoOut << S_PT[1] << std::endl; infoOut << "Signal ROI start" << std::endl; infoOut << S_ROI[0] << std::endl; infoOut << "Signal ROI stop" << std::endl; infoOut << S_ROI[1] << std::endl; infoOut << "Unzipped file size" << std::endl; infoOut << fileSize << std::endl; infoOut << "SPE charge histogram" << std::endl; for (int idx = 0; idx < 300; idx++) { infoOut << spe_charge_dist[idx] << " "; } infoOut << std::endl; infoOut << "Background - Peaks in pretrace histogram" << std::endl; for (int idx = 0; idx < 52; idx++) { infoOut << bg_pe_pt[idx] << " "; } infoOut << std::endl; infoOut << "Signal - Peaks in pretrace histogram" << std::endl; for (int idx = 0; idx < 52; idx++) { infoOut << s_pe_pt[idx] << " "; } infoOut << std::endl; infoOut << "CsI baseline histogram" << std::endl; for (int idx = 0; idx < 32; idx++) { infoOut << baseline_hist[idx] << " "; } infoOut << std::endl; infoOut << "Peak width distribution" << std::endl; for (int idx = 0; idx < 51; idx++) { infoOut << peak_width_distribution[idx] << " "; } infoOut << std::endl; infoOut << "PE amplitudes" << std::endl; for (int idx = 0; idx < 100; idx++) { infoOut << peak_height_dist[idx] << " "; } infoOut << std::endl; infoOut << "Big pulse onsets" << std::endl; for (int idx = 0; idx < bP_onset_arr.size(); idx++) { infoOut << bP_onset_arr[idx] << " "; } infoOut << std::endl; infoOut << "Big pulse charges" << std::endl; for (int idx = 0; idx < bP_charge_arr.size(); idx++) { infoOut << bP_charge_arr[idx] << " "; } infoOut << std::endl; infoOut << "All muon onsets - If linear gate present only the first is recorded" << std::endl; for (int idx = 0; idx < muon_onset_arr.size(); idx++) { infoOut << muon_onset_arr[idx] << " "; } infoOut << std::endl; infoOut << "Charge distribution in full waveform" << std::endl; for (int idx_1 = 0; idx_1 < 350; idx_1++) { bool printLine = false; for (int idx_2 = 0; idx_2 < 350; idx_2++) { if (charge_distribution[idx_1][idx_2] > 0) { printLine = true; break; } } if (printLine) { infoOut << idx_1 << " "; for (int idx_2 = 0; idx_2 < 350; idx_2++) { if (charge_distribution[idx_1][idx_2] > 0) { infoOut << idx_2 << " " << charge_distribution[idx_1][idx_2] << " "; } } infoOut << std::endl; } } infoOut.close(); } return 0; }
static int zip_append(const struct sr_output *o, unsigned char *buf, int unitsize, int length) { struct out_context *outc; struct zip *archive; struct zip_source *logicsrc; zip_int64_t num_files; struct zip_file *zf; struct zip_stat zs; struct zip_source *metasrc; GKeyFile *kf; GError *error; gsize len; int chunk_num, next_chunk_num, tmpfile, ret, i; const char *entry_name; char *metafile, tmpname[32], chunkname[16]; outc = o->priv; if (!(archive = zip_open(outc->filename, 0, &ret))) return SR_ERR; if (zip_stat(archive, "metadata", 0, &zs) == -1) return SR_ERR; metafile = g_malloc(zs.size); zf = zip_fopen_index(archive, zs.index, 0); zip_fread(zf, metafile, zs.size); zip_fclose(zf); /* * If the file was only initialized but doesn't yet have any * data it in, it won't have a unitsize field in metadata yet. */ error = NULL; kf = g_key_file_new(); if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, &error)) { sr_err("Failed to parse metadata: %s.", error->message); return SR_ERR; } g_free(metafile); tmpname[0] = '\0'; if (!g_key_file_has_key(kf, "device 1", "unitsize", &error)) { if (error && error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) { sr_err("Failed to check unitsize key: %s", error ? error->message : "?"); return SR_ERR; } /* Add unitsize field. */ g_key_file_set_integer(kf, "device 1", "unitsize", unitsize); metafile = g_key_file_to_data(kf, &len, &error); strcpy(tmpname, "sigrok-meta-XXXXXX"); if ((tmpfile = g_mkstemp(tmpname)) == -1) return SR_ERR; if (write(tmpfile, metafile, len) < 0) { sr_dbg("Failed to create new metadata: %s", strerror(errno)); g_free(metafile); unlink(tmpname); return SR_ERR; } close(tmpfile); if (!(metasrc = zip_source_file(archive, tmpname, 0, -1))) { sr_err("Failed to create zip source for metadata."); g_free(metafile); unlink(tmpname); return SR_ERR; } if (zip_replace(archive, zs.index, metasrc) == -1) { sr_err("Failed to replace metadata file."); g_free(metafile); unlink(tmpname); return SR_ERR; } g_free(metafile); } g_key_file_free(kf); next_chunk_num = 1; num_files = zip_get_num_entries(archive, 0); for (i = 0; i < num_files; i++) { entry_name = zip_get_name(archive, i, 0); if (strncmp(entry_name, "logic-1", 7)) continue; if (strlen(entry_name) == 7) { /* This file has no extra chunks, just a single "logic-1". * Rename it to "logic-1-1" * and continue with chunk 2. */ if (zip_rename(archive, i, "logic-1-1") == -1) { sr_err("Failed to rename 'logic-1' to 'logic-1-1'."); unlink(tmpname); return SR_ERR; } next_chunk_num = 2; break; } else if (strlen(entry_name) > 8 && entry_name[7] == '-') { chunk_num = strtoull(entry_name + 8, NULL, 10); if (chunk_num >= next_chunk_num) next_chunk_num = chunk_num + 1; } } snprintf(chunkname, 15, "logic-1-%d", next_chunk_num); if (!(logicsrc = zip_source_buffer(archive, buf, length, FALSE))) { unlink(tmpname); return SR_ERR; } if (zip_add(archive, chunkname, logicsrc) == -1) { unlink(tmpname); return SR_ERR; } if ((ret = zip_close(archive)) == -1) { sr_info("error saving session file: %s", zip_strerror(archive)); unlink(tmpname); return SR_ERR; } unlink(tmpname); return SR_OK; }