text
stringlengths 8
6.88M
|
|---|
//
// nextNum
// J. A. Pearson, jon@jpoffline.com
// Feb 2017
//
#pragma once
#include <vector>
#include <numeric>
#include <iostream>
#include "solution.h"
#include "tools.h"
namespace JP{
namespace UNIT{
struct UNIT_TEST_RETURN;
// Declare unit tests...
UNIT_TEST_RETURN TEST_pdftocdf();
UNIT_TEST_RETURN TEST_notfind_binary_search();
UNIT_TEST_RETURN TEST_find_binary_search();
UNIT_TEST_RETURN TEST_find_near_top_binary_search();
UNIT_TEST_RETURN TEST_find_end_binary_search();
UNIT_TEST_RETURN TEST_find_start_binary_search();
UNIT_TEST_RETURN TEST_find_start_idx_binary_search();
UNIT_TEST_RETURN TEST_find_end_idx_binary_search();
UNIT_TEST_RETURN TEST_validate_pdf();
UNIT_TEST_RETURN TEST_validate_fail_pdf();
UNIT_TEST_RETURN TEST_find_2_binary_search();
UNIT_TEST_RETURN TEST_equality_doubles();
UNIT_TEST_RETURN TEST_equality_string();
UNIT_TEST_RETURN TEST_equality_int();
UNIT_TEST_RETURN TEST_inequality_doubles();
UNIT_TEST_RETURN TEST_inequality_string();
UNIT_TEST_RETURN TEST_inequality_int();
UNIT_TEST_RETURN TEST_sumup();
UNIT_TEST_RETURN TEST_sumup_fail();
UNIT_TEST_RETURN TEST_sumup_string_fail();
UNIT_TEST_RETURN TEST_sumup_string();
bool analyse_test_results(
std::ostream& whereto,
std::vector<UNIT::UNIT_TEST_RETURN> results
);
bool run_tests(std::ostream& whereto);
bool run_tests();
}
}
namespace JP{
class UNIT::UNIT_TEST_RETURN
{
private:
bool pass;
std::string description;
public:
UNIT_TEST_RETURN(bool status, std::string desc) : pass(status), description(desc){}
UNIT_TEST_RETURN(std::string desc, bool status) : pass(status), description(desc){}
bool is_pass(){return pass;}
std::string get_desc(){return description;}
};
// Definitions of the unit tests...
UNIT::UNIT_TEST_RETURN UNIT::TEST_pdftocdf()
{
std::vector<double> pdf = {0.1,0.5,0.4};
auto cdf = pdftocdf<double>(pdf);
return UNIT::UNIT_TEST_RETURN(
"TEST_pdftocdf",
cdf[cdf.size() - 1] == 1
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_notfind_binary_search()
{
std::vector<double> values = {1.0, 10.0, 20.0, 50.0};
auto result = binary_search<double>(values, 0.0);
return UNIT::UNIT_TEST_RETURN(
"TEST_notfind_binary_search",
result == 0
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_find_binary_search()
{
std::vector<double> values = {1.0, 10.0, 20.0, 50.0};
auto result = binary_search<double>(values, 6.0);
return UNIT::UNIT_TEST_RETURN(
"TEST_find_binary_search",
result == 1
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_find_2_binary_search()
{
std::vector<double> values = {0.01, 0.3, 0.58, 0.1, 1};
auto result = binary_search<double>(values, 0.02);
return UNIT::UNIT_TEST_RETURN(
"TEST_find_2_binary_search",
result == 1
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_find_near_top_binary_search()
{
std::vector<double> values = {1.0, 10.0, 20.0, 50.0};
auto result = binary_search<double>(values, 49.0);
return UNIT::UNIT_TEST_RETURN(
"TEST_find_near_top_binary_search",
result == 3
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_find_end_binary_search()
{
std::vector<double> values = {1.0, 10.0, 20.0, 50.0};
auto result = binary_search<double>(values, 50.0);
return UNIT::UNIT_TEST_RETURN(
"TEST_find_end_binary_search",
result == 3
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_find_start_binary_search()
{
std::vector<double> values = {1.0, 10.0, 20.0, 50.0};
auto result = binary_search<double>(values, 1.0);
return UNIT::UNIT_TEST_RETURN(
"TEST_find_start_binary_search",
result == 0
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_find_start_idx_binary_search()
{
std::vector<double> values = {1.0, 10.0, 20.0, 50.0};
auto result = binary_search<double>(values, 1.0);
return UNIT::UNIT_TEST_RETURN(
"TEST_find_start_idx_binary_search",
result == 0
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_find_end_idx_binary_search()
{
std::vector<double> values = {1.0, 10.0, 20.0, 50.0};
auto result = binary_search<double>(values, 50.0);
return UNIT::UNIT_TEST_RETURN(
"TEST_find_end_idx_binary_search",
result == 3
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_validate_pdf()
{
std::vector<double> values {0.01, 0.3, 0.58, 0.1, 0.01};
auto result = sumup<double>(values);
return UNIT::UNIT_TEST_RETURN(
"TEST_validate_pdf",
test_equalty<double>(result,1)
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_validate_fail_pdf()
{
std::vector<double> values {0.01, 0.3, 0.58, 0.1, 0.1};
auto result = sumup<double>(values);
return UNIT::UNIT_TEST_RETURN(
"TEST_validate_fail_pdf",
!test_equalty<double>(result,1)
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_equality_doubles()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_equality_doubles",
test_equalty<double>(1.0,1.0)
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_inequality_doubles()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_inequality_doubles",
!test_equalty<double>(1.0,0.0)
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_equality_string()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_equality_string",
test_equalty<std::string>("hello", "hello")
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_inequality_string()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_inequality_string",
!test_equalty<std::string>("hello", "world")
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_equality_int()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_equality_int",
test_equalty<int>(1,1)
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_inequality_int()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_inequality_int",
!test_equalty<int>(1,2)
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_sumup()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_sumup",
JP::sumup<double>(std::vector<double>{1.0,2.0}) == 3.0
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_sumup_fail()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_sumup_fail",
!(JP::sumup<double>(std::vector<double>{1.0,2.0}) == 4.0)
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_sumup_string_fail()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_sumup_string_fail",
!(JP::sumup<std::string>(std::vector<std::string>{"hello", " world"}) == "hello world me")
);
}
UNIT::UNIT_TEST_RETURN UNIT::TEST_sumup_string()
{
return UNIT::UNIT_TEST_RETURN(
"TEST_sumup_string",
JP::sumup<std::string>(std::vector<std::string>{"hello", " world"}) == "hello world"
);
}
bool UNIT::run_tests(
){
return run_tests(std::cout);
}
bool UNIT::run_tests(
std::ostream& whereto
){
return(
analyse_test_results(
whereto,
std::vector<UNIT::UNIT_TEST_RETURN>{
TEST_pdftocdf(),
TEST_notfind_binary_search(),
TEST_find_binary_search(),
TEST_find_end_binary_search(),
TEST_find_start_binary_search(),
TEST_find_near_top_binary_search(),
TEST_find_start_idx_binary_search(),
TEST_find_end_idx_binary_search(),
TEST_validate_pdf(),
TEST_validate_fail_pdf(),
TEST_find_2_binary_search(),
TEST_equality_int(),
TEST_equality_doubles(),
TEST_equality_string(),
TEST_inequality_int(),
TEST_inequality_doubles(),
TEST_inequality_string(),
TEST_sumup(),
TEST_sumup_fail(),
TEST_sumup_string_fail(),
TEST_sumup_string()
}
)
);
}
bool
UNIT::analyse_test_results(
std::ostream& whereto,
std::vector<UNIT::UNIT_TEST_RETURN> results
){
int nfail = 0;
int npass = 0;
for(auto & r : results)
{
if(!r.is_pass())
{
nfail++;
whereto << "FAIL: " << r.get_desc() << "\n";
}
else
{
npass++;
}
}
whereto << "---------------------------------\n";
whereto << "TESTS run" << "\n";
whereto << " #tests: " << npass + nfail << "\n";
whereto << " #fails: " << nfail << "\n";
whereto << " #pass: " << npass << "\n";
if(nfail == 0)
{
whereto << "SUCCESS!\n";
}
else
{
whereto << "FAIL!\n";
}
whereto << "---------------------------------\n";
return nfail == 0;
}
}
|
#include <gtest/gtest.h>
#include <NDT/Tensor.h>
namespace {
using namespace NDT;
TEST(TensorElementAccessTest, Test1D) {
float data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Tensor<1, float, HostResident> tensor(10, data);
for (int i = 0; i < 10; ++i) {
EXPECT_EQ(i, tensor(i));
}
Tensor<1, float, HostResident, true> constTensor = tensor;
tensor(7) = 3;
EXPECT_EQ(3, tensor(7));
EXPECT_EQ(3, constTensor(7));
}
TEST(TensorElementAccessTest, Test2D) {
uint64_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
Tensor<2, uint64_t, HostResident> tensor({3, 3}, data);
for (int j = 0; j < 3; ++j) {
for (int i = 0; i < 3; ++i) {
EXPECT_EQ(i + 3 * j, tensor(i, j));
}
}
Tensor<2, uint64_t, HostResident, true> constTensor = tensor;
tensor(1,2) = 13;
EXPECT_EQ(13, tensor(1,2));
EXPECT_EQ(13, constTensor(1,2));
}
TEST(TensorElementAccessTest, Test3D) {
int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
Tensor<3, int, HostResident> tensor({2, 4, 2}, data);
for (int k = 0; k < 2; ++k) {
for (int j = 0; j < 4; ++j) {
for (int i = 0; i < 2; ++i) {
EXPECT_EQ(i + 2 * (j + 4 * k), tensor(i, j, k));
}
}
}
Tensor<3, int, HostResident, true> constTensor = tensor;
tensor(1,2,0) = -1;
EXPECT_EQ(-1, tensor(1,2,0));
EXPECT_EQ(-1, constTensor(1,2,0));
}
TEST(TensorElementAccessTest, Test4D) {
double data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
Tensor<4, double, HostResident> tensor({2, 2, 2, 2}, data);
for (int l = 0; l < 2; ++l) {
for (int k = 0; k < 2; ++k) {
for (int j = 0; j < 2; ++j) {
for (int i = 0; i < 2; ++i) {
EXPECT_EQ(i + 2 * (j + 2 * (k + 2 * l)), tensor(i, j, k,l));
}
}
}
}
Tensor<4, double, HostResident, true> constTensor = tensor;
tensor(1,0,0,1) = 2.5;
EXPECT_EQ(2.5, tensor(1,0,0,1));
EXPECT_EQ(2.5, constTensor(1,0,0,1));
}
} // namespace
|
/**
* count number of nodes in the binary search tree in the specified
* range.
6
4 7
3 12
2 11 16
0 10 22
32
62
*
*
* */
#include <iostream>
#include <limits>
#include <queue>
typedef struct Node {
Node(int _d, Node *_left, Node *_right) :
data(_d), left(_left), right(_right) {}
int incrementLeft() {
return leftCount++;
}
int incrementRight() {
return rightCount++;
}
int data;
Node *left;
Node *right;
int leftCount;
int rightCount;
};
Node* insertNode(Node *root, int data) {
if (root->data <= data) {
root -> incrementRight();
if (root->right == NULL) {
root->right = new Node(data, NULL, NULL);
} else {
insertNode(root->right, data);
}
} else {
root -> incrementLeft();
if (root->left == NULL) {
root->left = new Node(data, NULL, NULL);
} else {
insertNode(root->left, data);
}
}
return root;
}
void printBstByLevel(Node *root) {
if (root == NULL) return;
int currentLevel = 1;
int nextLevel = 0;
std::queue<Node *> Queue;
Queue.push(root);
Node *temp;
while (!Queue.empty()) {
temp = Queue.front();
currentLevel -= 1;
Queue.pop();
std::cout << temp->data <<" (" << temp->leftCount << ", " << temp->rightCount << ") ";
if (temp -> left != NULL) {
Queue.push(temp->left);
nextLevel += 1;
}
if (temp -> right != NULL) {
Queue.push(temp -> right);
nextLevel += 1;
}
if (currentLevel == 0) {
std::cout << "" << std::endl;
currentLevel = nextLevel;
nextLevel = 0;
}
}
}
Node * create_binary_tree(){
Node *root = new Node(6, NULL, NULL);
root = insertNode(root, 7);
root = insertNode(root, 4);
root = insertNode(root, 3);
root = insertNode(root, 2);
root = insertNode(root, 12);
root = insertNode(root, 16);
root = insertNode(root, 22);
root = insertNode(root, 32);
root = insertNode(root, 62);
root = insertNode(root, 0);
root = insertNode(root, 11);
root = insertNode(root, 10);
if (root->left == NULL || root->right == NULL) {
std::cout << "Dammit" << std::endl;
}
return root;
}
int countInRange(Node *root, int min, int max, int &count) {
if (root == NULL) return 0;
if (root->data <= min && root->right != NULL) {
countInRange(root->right, min, max, count);
} else if (root -> data >= max && root->left != NULL) {
countInRange(root->left, min, max, count);
} else if (root->data > min && root -> data < max) {
std::cout << "[A] " << root->data << std::endl;
count++;
countInRange(root->left, min, max, count); // only increment it once.
countInRange(root->right, min, max, count);
}
return count;
}
int main(void) {
int max = std::numeric_limits<int>::max();
int min = std::numeric_limits<int>::min();
int count = 0;
Node *root = create_binary_tree();
std::cout << "---------------------" << std::endl;
std::cout << countInRange(root, 1, 11, count) << std::endl;
std::cout << "---------------------" << std::endl;
printBstByLevel(root);
return EXIT_SUCCESS;
}
|
//算法:hash哈希表
//一道哈希表例题
//对于一个数,如果hash表中未出现过,
//则加入表中,并将其输出
//如果出现过,则直接跳过
//这样就能做到去重并输出的效果
#include<cstdio>
#include<vector>
using namespace std;
const int mod = 1145141;
vector <int> ha[mod+1];
bool judge(int x)//判断是否出现,并加入表中
{
int k=x%mod;
int l=ha[k].size();
for(int i=0;i<l;i++)
if(ha[k][i]==x) return 0;
ha[k].push_back(x);
return 1;
}
int main()
{
int t,n,x;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&x);//判断是否出现,并输出
if(judge(x)) printf("%d ",x);
}
printf("\n");
for(int i=1;i<=mod;i++)//清空表
ha[i].clear();
}
}
|
#ifndef SPECEX_HERMITE__H
#define SPECEX_HERMITE__H
#include <specex_unbls.h>
namespace specex {
double HermitePol(const int Degree, const double &x);
double HermitePolDerivative(const int Degree, const double &x);
}
#endif
|
/*
* Copyright (c) 2016, The Regents of the University of California (Regents).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Please contact the author(s) of this library if you have any questions.
* Author: Erik Nelson ( eanelson@eecs.berkeley.edu )
*/
#include <raytracing/lens_raytracer.h>
#include <shading/material_handler.h>
#include <shading/shader_factory.h>
#include <strings/join_filepath.h>
#include <iostream>
LensRaytracer::LensRaytracer()
: mx0_(0.0),
my0_(0.0),
mx1_(0.0),
my1_(0.0),
mdx_(0.0),
mdy_(0.0),
vertical_angle_(0.0),
horizontal_angle_(0.0),
window_width_(0),
window_height_(0),
draw_axes_(false),
update_mouse_(true) {}
LensRaytracer::~LensRaytracer() {
// Delete shaders.
delete ShaderFactory::Instance();
}
bool LensRaytracer::Initialize(int window_width, int window_height) {
// Set window width and height.
window_width_ = window_width;
window_height_ = window_height;
// Load shaders.
const std::string vertex_shader =
strings::JoinFilepath(LR3D_SHADER_DIR, "vertex.vs");
const std::string fragment_shader =
strings::JoinFilepath(LR3D_SHADER_DIR, "fragment.fs");
if (!ShaderFactory::Instance()->Initialize("Lens Raytracer", vertex_shader,
fragment_shader)) {
std::cerr << "Failed to initialize shaders." << std::endl;
return false;
}
LinkShader();
// Initialize viewing vectors.
eye_ = glm::vec3(0.0, 0.0, -5.0);
lookat_ = glm::vec3(0.0, 0.0, 0.0);
up_ = glm::vec3(0.0, 1.0, 0.0);
// Load the scene.
const std::string scene_file =
strings::JoinFilepath(LR3D_CONFIG_DIR, LR3D_SCENE_FILE);
scene_.LoadFromFile(scene_file);
scene_.MakeBufferObjects();
scene_.ComputePaths();
return true;
}
void LensRaytracer::Update(GLFWwindow* window, double elapsed,
double total_elapsed) {
const glm::vec3 forward = glm::normalize(lookat_ - eye_);
const glm::vec3 right = glm::normalize(glm::cross(forward, up_));
if (glfwGetKey(window, 'W')) {
eye_ += forward * static_cast<float>(total_elapsed);
}
if (glfwGetKey(window, 'S')) {
eye_ -= forward * static_cast<float>(total_elapsed);
}
if (glfwGetKey(window, 'D')) {
eye_ += right * static_cast<float>(total_elapsed);
}
if (glfwGetKey(window, 'A')) {
eye_ -= right * static_cast<float>(total_elapsed);
}
if (glfwGetKey(window, 'Q')) {
eye_ += up_ * static_cast<float>(total_elapsed);
}
if (glfwGetKey(window, 'E')) {
eye_ -= up_ * static_cast<float>(total_elapsed);
}
if (glfwGetKey(window, 'F')) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
if (glfwGetKey(window, 'G')) {
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
if (glfwGetKey(window, 'V')) {
draw_axes_ = true;
}
if (glfwGetKey(window, 'B')) {
draw_axes_ = false;
}
if (glfwGetKey(window, 'N')) {
update_mouse_ = false;
}
if (glfwGetKey(window, 'M')) {
update_mouse_ = true;
}
// Check for mouse input.
glfwGetCursorPos(window, &mx1_, &my1_);
if (update_mouse_) {
// Handle the very first update call.
if (mx0_ == 0 && my0_ == 0) {
mx0_ = mx1_;
my0_ = my1_;
}
// Compute delta mouse input.
mdx_ = mx1_ - mx0_;
mdy_ = my1_ - my0_;
// Set old mouse positions.
mx0_ = mx1_;
my0_ = my1_;
// Apply rotations.
vertical_angle_ -= mdy_ / 400.0;
horizontal_angle_ -= mdx_ / 400.0;
// Limit user to looking up or down 85 degrees in either direction.
if (vertical_angle_ > max_angle_) {
vertical_angle_ = max_angle_;
} else if (vertical_angle_ < -max_angle_) {
vertical_angle_ = -max_angle_;
}
}
lookat_ = glm::vec3(eye_.x + cos(vertical_angle_) * sin(horizontal_angle_),
eye_.y + sin(vertical_angle_),
eye_.z + cos(vertical_angle_) * cos(horizontal_angle_));
}
void LensRaytracer::Render(double elapsed, double total_elapsed) {
// Set up model, view, and projection matrices.
ResetModel();
ModelTransform();
ProjectionTransform();
ViewTransform();
// Set camera position.
glUniform3f(camera_pos_, eye_.x, eye_.y, eye_.z);
// Render the scene.
scene_.Render(draw_axes_, eye_);
}
void LensRaytracer::LinkShader() {
// Get vertex and fragment shader.
static Shader* shader =
ShaderFactory::Instance()->GetShader("Lens Raytracer");
// Link matrices.
model_matrix_ = glGetUniformLocation(shader->GetProgram(), "u_model_matrix");
view_matrix_ = glGetUniformLocation(shader->GetProgram(), "u_view_matrix");
proj_matrix_ = glGetUniformLocation(shader->GetProgram(), "u_proj_matrix");
// Link camera position and look direction.
camera_pos_ = glGetUniformLocation(shader->GetProgram(), "u_camera_position");
// Link shader materials with material handler object on CPU side.
MaterialHandler::Instance()->LinkWithShader(shader);
// Start using the shader.
shader->Use();
}
void LensRaytracer::ResetModel() {
// Get handle to model matrix and set to identity.
glUniformMatrix4fv(model_matrix_, 1, GL_FALSE,
glm::value_ptr(glm::mat4(1.f)));
}
void LensRaytracer::ModelTransform() {}
void LensRaytracer::ViewTransform() {
// Set the view matrix based on the eye, lookat, and up vectors.
const glm::mat4 view = glm::lookAt(eye_, lookat_, up_);
glUniformMatrix4fv(view_matrix_, 1, GL_FALSE, glm::value_ptr(view));
}
void LensRaytracer::ProjectionTransform() {
// Create a projection matrix using the window aspect ratio and a desired
// horizontal fov.
const float aspect_ratio =
static_cast<float>(window_width_) / static_cast<float>(window_height_);
const float hfov = 120.f;
const float near_plane = 0.1f;
const float far_plane = 400.f;
const glm::mat4 proj =
glm::perspective(hfov, aspect_ratio, near_plane, far_plane);
glUniformMatrix4fv(proj_matrix_, 1, GL_FALSE, glm::value_ptr(proj));
}
|
#include <iostream>
#include <cstdio>
using namespace std;
/*int fun(int x) {
if(x == 1)
return 1;
else
return x * fun(x - 1);
}
*/
int main(){
double sum = 0, temp = 1;
for(int i = 1; i <= 30; i++) {
for(int j = 1; j <= i; j++) {
temp *= j;
}
sum += temp;
temp = 1;
}
printf("%.2e\n", sum);
return 0;
}
|
#include <iostream>
#include "EmpleadoPorComision.h"
EmpleadoPorComision::EmpleadoPorComision(const std::string & a, const std::string & b, const std::string & c, double d=0.0 , double e= 0.0){
primerNombre=a;
apellidoPaterno=b;
numeroSeguroSocial=c;
ventasBrutas=d;
tarifaComision=e;
}
void EmpleadoPorComision::setPrimerNombre(const std::string p){
primerNombre = p;
}
std::string EmpleadoPorComision::getPrimerNombre() const{
return primerNombre;
};
void EmpleadoPorComision::setApellidoPaterno(const std::string & p){
apellidoPaterno = p;
}
std::string EmpleadoPorComision::getApellidoPaterno() const{
return apellidoPaterno;
}
void EmpleadoPorComision::setNumeroSeguroSocial(const std::string & p){
numeroSeguroSocial = p;
}
std::string EmpleadoPorComision::getNumeroSeguroSocial() const{
return numeroSeguroSocial;
}
void EmpleadoPorComision::setVentasBrutas(double p){
ventasBrutas = p;
}
double EmpleadoPorComision::getVentasBrutas() const{
return ventasBrutas;
}
void EmpleadoPorComision::setTarifaComision(double p){
tarifaComision = p;
}
double EmpleadoPorComision::getTarifaComision() const{
return tarifaComision;
}
double EmpleadoPorComision::ingresos(){
return tarifaComision * ventasBrutas;
}
void EmpleadoPorComision::imprimir(){
std::cout<< "empleado por comision: " << primerNombre << ' ' << apellidoPaterno <<
'/nNumero de Seguridad Social: '<< numeroSeguroSocial <<
'/nVentas Brutas: '<< ventasBrutas<<
'/nTarifa de Comisi[on: '<< tarifaComision;
}
|
#pragma once
#include "../../Toolbox/Toolbox.h"
#include "../Vector/Vector3.h"
#include "../Rotator/Rotator.h"
namespace ae
{
/// \ingroup math
/// <summary>
/// Useful to do 3D transformations like translation, rotation and scaling.
/// </summary>
/// <seealso cref="Matrix4x4"/>
/// <seealso cref="Vector3"/>
class AERO_CORE_EXPORT Transform
{
public:
/// <summary>
/// Default constructor. <para/>
/// Set transform to identity : position and rotation to 0 and scale to 1.
/// </summary>
Transform();
/// <summary>
/// Default constructor. <para/>
/// Rotation set to 0 and scale to 1.
/// </summary>
/// <param name="_Position">Translation to apply to the transform.</param>
Transform( const Vector3& _Position );
/// <summary>Constructor with all component of the transform.</summary>
/// <param name="_Position">Translation to apply to the transform.</param>
/// <param name="_Rotation">Rotation to apply to the transform.</param>
/// <param name="_Scale">Scale to apply to the transform.</param>
Transform( const Vector3& _Position, const Rotator& _Rotation, const Vector3& _Scale );
/// <summary>Default destructor, we define it to mark it as virtual for subclasses.</summary>
virtual ~Transform() = default;
/// <summary>Set the position of the transform.</summary>
/// <param name="_X">New position x.</param>
/// <param name="_Y">New position y.</param>
/// <param name="_Z">New position z.</param>
void SetPosition( float _X, float _Y, float _Z );
/// <summary>Set the position of the transform.</summary>
/// <param name="_Position">New position.</param>
void SetPosition( const ae::Vector3& _Position );
/// <summary>Translate the position of the transform.</summary>
/// <param name="_Offset">Offset to add to the position.</param>
void Translate( const Vector3& _Offset );
/// <summary>Translate the position of the transform.</summary>
/// <param name="_X">Offset to add to the x position.</param>
/// <param name="_Y">Offset to add to the y position.</param>
/// <param name="_Z">Offset to add to the z position.</param>
void Translate( float _X, float _Y, float _Z );
/// <summary>Get the transform position.</summary>
/// <returns>Transform position.</returns>
const Vector3& GetPosition() const;
/// <summary>Set the rotation of the transform.</summary>
/// <param name="_Pitch">Rotation around the right axis.</param>
/// <param name="_Yaw">Rotation around the up axis.</param>
/// <param name="_Roll">Rotation around the look axis.</param>
void SetRotation( float _Pitch, float _Yaw, float _Roll );
/// <summary>Set the rotation of the transform.</summary>
/// <param name="_Angles">Angles to apply to the transform ( x = Pitch, y = Yaw, z = Roll ).</param>
void SetRotation( const Vector3& _Angles );
/// <summary>Set the rotation of the transform.</summary>
/// <param name="_Rotation">The new rotation to apply.</param>
void SetRotation( const Rotator& _Rotation );
/// <summary>Add a rotation to the current rotation of the transform.</summary>
/// <param name="_Pitch">Rotation around the right axis.</param>
/// <param name="_Yaw">Rotation around the up axis.</param>
/// <param name="_Roll">Rotation around the look axis.</param>
void Rotate( float _Pitch, float _Yaw, float _Roll );
/// <summary>Add a rotation to the current rotation of the transform.</summary>
/// <param name="_Angles">Angles to apply to the transform ( x = Pitch, y = Yaw, z = Roll ).</param>
void Rotate( const Vector3& _Angles );
/// <summary>Add a rotation to the current rotation of the transform.</summary>
/// <param name="_Rotation">The new rotation to add to the current one.</param>
void Rotate( const Rotator& _Rotation );
/// <summary>Get the transform rotation as euler angle.</summary>
/// <returns>Transform rotation ( x = Pitch, y = Yaw, z = Roll ).</returns>
const Vector3& GetRotationAngles() const;
/// <summary>Get the transform rotation as a rotator.</summary>
/// <returns>Transform rotation.</returns>
const Rotator& GetRotation() const;
/// <summary>Set the scale of the transform.</summary>
/// <param name="_X">New scale x.</param>
/// <param name="_Y">New scale y.</param>
/// <param name="_Z">New scale z.</param>
void SetScale( float _X, float _Y, float _Z );
/// <summary>Set the scale of the transform.</summary>
/// <param name="_Scale">New scale .</param>
void SetScale( const Vector3& _Scale );
/// <summary>Combine a new scale the current one.</summary>
/// <param name="_X">Scale to add to the x scale.</param>
/// <param name="_Y">Scale to add to the y scale.</param>
/// <param name="_Z">Scale to add to the z scale.</param>
void Scale( float _X, float _Y, float _Z );
/// <summary>Scale the scale of the transform.</summary>
/// <param name="_Scale">Scale to add to the scale.</param>
void Scale( const Vector3& _Scale );
/// <summary>Get the transform scale.</summary>
/// <returns>Transform scale.</returns>
const Vector3& GetScale() const;
/// <summary>Combine the calling transform with another one.</summary>
/// <param name="_Other">Other transform to combine transformations with.</param>
void Combine( const Transform& _Other );
/// <summary>Combine two transforms.</summary>
/// <param name="_Transform1">First transform from which take transformations.</param>
/// <param name="_Transform2">Second transform from which take transformations.</param>
/// <returns>Transform containing the transformations from both transforms.</returns>
static Transform Combine( const Transform& _Transform1, const Transform& _Transform2 );
/// <summary>
/// Combine two transforms and put the result in the third one. <para/>
/// This function do the same thing as "Transform Combine( Transform, Transform )". <para/>
/// But it will not create a new transform and copy it for the return, so this function is recommended for optimizations.
/// </summary>
/// <param name="_Transform1">First transform from which take transformations.</param>
/// <param name="_Transform2">Second transform from which take transformations.</param>
/// <param name="_Result">Transform to fill with the transformations from both transforms.</param>
static void Combine( const Transform& _Transform1, const Transform& _Transform2, Transform& _Result );
/// <summary>Get the transform as a matrix4x4.</summary>
/// <returns>Matrix4x4 representing the transform.</returns>
const Matrix4x4& GetMatrix();
/// <summary>
/// Get a copy of updated transform as a matrix4x4. <para/>
/// Used for internal rendering functions.
/// </summary>
/// <returns>Matrix4x4 representing the transform.</returns>
Matrix4x4 GetUpdatedMatrix();
/// <summary>Get the transform as a matrix4x4 inversed.</summary>
/// <returns>Matrix4x4 inversed representing the transform.</returns>
Matrix4x4 GetInversedMatrix();
/// <summary>Get the transform as a matrix 4x4 transposed.</summary>
/// <returns>Matrix4x4 transposed representing the transform.</returns>
Matrix4x4 GetTransposedMatrix();
/// <summary>Get the forward vector of the transform.</summary>
/// <returns>Forward vector of the transform.</returns>
Vector3 GetForward();
/// <summary>Get the left vector of the transform.</summary>
/// <returns>Left vector of the transform.</returns>
Vector3 GetLeft();
/// <summary>Get the Up vector of the transform.</summary>
/// <returns>Up vector of the transform.</returns>
Vector3 GetUp();
/// <summary>Set the pivot of the transformation.</summary>
/// <param name="_Pivot">The new pivot to apply.</param>
void SetPivot( const Vector3& _Pivot );
/// <summary>Retrieve the current transformation pivot.</summary>
/// <returns>The current transformation pivot.</returns>
const Vector3& GetPivot();
/// <summary>
/// Function called by the editor.
/// It allows the class to expose some attributes for user editing.
/// Think to call all inherited class function too when overloading.
/// </summary>
virtual void ToEditor();
protected:
/// <summary>Process the tranform's matrix.</summary>
void UpdateTransform();
/// <summary>Additionnal process to do in UpdateTransform.</summary>
virtual void OnTransformUpdated();
/// <summary>Alert subclasses of changement of transform component.</summary>
virtual void OnTransformChanged();
protected:
/// <summary>3D position.</summary>
Vector3 m_Position;
/// <summary>3D rotation.</summary>
Rotator m_Rotation;
/// <summary>3D Scale.</summary>
Vector3 m_Scale;
/// <summary>Transformation pivot.</summary>
Vector3 m_Pivot;
/// <summary>Transform as matrix 4x4.</summary>
Matrix4x4 m_Transform;
private:
/// <summary>Used to know if the matrix must be updated or not.</summary>
Bool m_UpdateTransform;
};
} // ae
|
#pragma once
#include "Core/Core.h"
#include "Render/DispatchPass/BaseDispatchPass.h"
namespace Rocket
{
class SkyBoxGenerate : implements BaseDispatchPass
{
public:
void Dispatch(Frame& frame);
};
}
|
#include "stdafx.h"
#include "CPrimitive.h"
CPrimitive::CPrimitive()
{
}
CPrimitive::~CPrimitive()
{
Release();
}
void CPrimitive::Release()
{
m_vertexBuffer.Release();
m_indexBuffer.Release();
}
bool CPrimitive::Create(
D3D_PRIMITIVE_TOPOLOGY topology,
int numVertex,
int vertexStride,
void* pSrcVertexBuffer,
int numIndex,
CIndexBuffer::EnIndexType indexType,
void* pSrcIndexBuffer)
{
Release();
bool result = m_vertexBuffer.Create(numVertex, vertexStride, pSrcVertexBuffer);
if (!result) {
//TK_WARNING("プリミティブの作成に失敗しました。");
return false;
}
result = m_indexBuffer.Create(numIndex, indexType, pSrcIndexBuffer);
if (!result) {
//TK_WARNING("プリミティブの作成に失敗しました。");
return false;
}
return true;
}
void CPrimitive::Draw(CRenderContext& rc)
{
//頂点バッファを設定。
rc.IASetVertexBuffer(m_vertexBuffer);
rc.IASetIndexBuffer(m_indexBuffer);
//プリミティブのトポロジーを設定。
rc.IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
//描画。
rc.DrawIndexed(m_indexBuffer.GetNumIndex(), 0, 0);
}
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
typedef std::vector<ll> vi;
typedef std::vector<std::vector<ll> > vv;
#define MOD 1000000007
#define IO ios_base::sync_with_stdio(false);cin.tie(NULL);
#define fo(i,a,b) for(i=a;i<b;i++)
#define mp make_pair
#define pb(x) push_back(x)
#define fi first
#define se second
#define print(vec,a,b) for(ll i=a;i<b;i++) cout<<vec[i]<<" ";cout<<endl;
#define all(a) a.begin(),a.end()
#define input(vec,a,b) for(ll i = a;i<b;i++) cin>>vec[i];
#define ms(a,val) memset(a,val,sizeof(a))
using namespace std;
const int N = 1e5 + 5;
void solve(){
ll i,j,n,m,k;
cin>>n;
ll a[n+1];
input(a,1,n+1);
vi freq[n+1];
fo(i,1,n+1)
{
freq[a[i]].pb(i);
}
ll maxx[n+1];
fo(i,1,n+1)
maxx[i] = INT_MIN;
fo(i,1,n+1)
{
if(freq[i].size()==0)
continue;
maxx[i] = freq[i][0];
fo(j,1,freq[i].size())
{
ll temp = freq[i][j] - freq[i][j-1];
maxx[i] = max(temp,maxx[i]);
}
maxx[i] = max(maxx[i], n - freq[i][freq[i].size()-1]+1);
}
ll dp[n+1];
fo(i,1,n+1)
dp[i] = INT_MAX;
fo(i,1,n+1)
{
if(maxx[i]==INT_MIN)
continue;
dp[maxx[i]] = min(dp[maxx[i]],i);
}
fo(i,2,n+1)
dp[i] = min(dp[i-1],dp[i]);
fo(i,1,n+1)
{
if(dp[i]==INT_MAX)
cout<<"-1 ";
else
cout<<dp[i]<< " ";
}
cout<<endl;
}
int main()
{
IO;
ll t=1;
cin>>t;
while(t--)
{
solve();
}
return 0;
}
|
//
// cut_rod_ref.hpp
// rod-cut
//
// Created by mndx on 26/10/2021.
//
#ifndef cut_rod_ref_hpp
#define cut_rod_ref_hpp
#include <stdio.h>
void ext_bu_cut_rod(int p[], int n, int r[], int s[]);
void print_cut_rod_sol(int p[], int n);
#endif /* cut_rod_ref_hpp */
|
#include "manager.h"
/**
* @brief Manager::Manager
*/
Manager::Manager(unsigned int _n) : m_state(_n), m_totalTime(0.0)
{
}
Manager::~Manager() {
}
|
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s; cin >> s;
int abcd[4];
for (int i = 0; i < 4; i++) abcd[i] = s[i] - '0';
if (abcd[0] + abcd[1] + abcd[2] + abcd[3] == 7) {
cout << abcd[0] << "+" << abcd[1] << "+" << abcd[2] << "+" << abcd[3] << "=7" << endl;
} else if (abcd[0] + abcd[1] + abcd[2] - abcd[3] == 7) {
cout << abcd[0] << "+" << abcd[1] << "+" << abcd[2] << "-" << abcd[3] << "=7" << endl;
} else if (abcd[0] + abcd[1] - abcd[2] - abcd[3] == 7) {
cout << abcd[0] << "+" << abcd[1] << "-" << abcd[2] << "-" << abcd[3] << "=7" << endl;
} else if (abcd[0] + abcd[1] - abcd[2] + abcd[3] == 7) {
cout << abcd[0] << "+" << abcd[1] << "-" << abcd[2] << "+" << abcd[3] << "=7" << endl;
} else if (abcd[0] - abcd[1] + abcd[2] + abcd[3] == 7) {
cout << abcd[0] << "-" << abcd[1] << "+" << abcd[2] << "+" << abcd[3] << "=7" << endl;
} else if (abcd[0] - abcd[1] - abcd[2] + abcd[3] == 7) {
cout << abcd[0] << "-" << abcd[1] << "-" << abcd[2] << "+" << abcd[3] << "=7" << endl;
} else if (abcd[0] - abcd[1] + abcd[2] - abcd[3] == 7) {
cout << abcd[0] << "-" << abcd[1] << "+" << abcd[2] << "-" << abcd[3] << "=7" << endl;
} else if (abcd[0] - abcd[1] - abcd[2] - abcd[3] == 7) {
cout << abcd[0] << "-" << abcd[1] << "-" << abcd[2] << "-" << abcd[3] << "=7" << endl;
}
return 0;
}
|
#ifndef BASE_SCHEDULING_TASK_LOOP_H_
#define BASE_SCHEDULING_TASK_LOOP_H_
#include <memory>
#include <queue>
#include "base/callback.h"
#include "base/scheduling/task_runner.h"
#include "base/synchronization/condition_variable.h"
#include "base/synchronization/mutex.h"
#include "base/threading/thread.h"
namespace base {
// |TaskLoop| is owned long-term, solely by the owner of |Thread::Delegate|
// (concretely, that's |Thread|). However, we have to inherit from
// |std::enable_shared_from_this| so that we can hand std::weak_ptr<TaskLoop>s
// out to |TaskRunner|. We should never handing std::shared_ptr<TaskLoop>s out
// to anyone, and the std::weak_ptr<TaskLoop>s owned by |TaskRunner| should only
// should ever take ownership of this object for the brief period of time it
// needs to post a task. For more information see the documentation above
// |TaskRunner|.
class TaskLoop : public Thread::Delegate,
public TaskRunner::Delegate,
public std::enable_shared_from_this<TaskLoop> {
public:
TaskLoop() = default;
virtual ~TaskLoop() = default;
TaskLoop(TaskLoop&) = delete;
TaskLoop(TaskLoop&&) = delete;
TaskLoop& operator=(const TaskLoop&) = delete;
static std::shared_ptr<TaskLoop> CreateUnbound(ThreadType type);
static std::shared_ptr<TaskLoop> Create(ThreadType type);
// Thread::Delegate implementation.
// This method does two things:
// 1. Binds process-global |TaskLoop| pointers for well-known threads.
// Depending on the type of TaskLoop |this| is, we may bind |this| to the
// process-global TaskLoop handle corresponding to |type|. This is so
// that from a process's UI thread, you can get a |TaskLoop| or
// |TaskRunner| reference to the same process's IO thread, and vice
// versa. We don't do this for ThreadType::WORKER threads/loops, because
// there could be an arbitrary number of these threads in a process,
// whereas the UI/IO threads are considered well-known, and unique within
// a process.
// 2. Binds thread-global |TaskLoop| and |TaskRunner| pointers.
// We bind |this| and |this->GetTaskRunner()| to the corresponding
// thread_local "global" pointers. This allows all tasks running on the
// current thread to grab a |TaskLoop| (aka |this|), or |TaskRunner|
// reference associated with |this| for convenience. This is done
// for all thread types, since the results are only visible with in the
// current thread.
void BindToCurrentThread(ThreadType type) override;
// Called on the thread that |this| is bound to.
void Run() override = 0;
// Can be called from any thread.
void Quit() override = 0;
// Can be called from any thread. Just like |Quit()|, but instead of setting
// |quit_| to true, we set |quit_when_idle_| to true, which only quits the run
// loop if it has no tasks to process. This method basically turns this
// instance of the loop into a run-until-idle loop. The reason we introduce it
// is so that we can let the loop run for a while (potentially idling along
// the way), and then post some tasks to finish up, and wait for those tasks
// to finish. This is most useful in a multi-thread environment.
void QuitWhenIdle() override = 0;
// Can be called from any thread.
std::shared_ptr<TaskRunner> GetTaskRunner() override;
// TaskRunner::Delegate implementation.
// Can be called from any thread.
void PostTask(Callback cb) override = 0;
// Called on the thread that |this| is bound to. Just like |Run()|, except it
// runs the loop until the underlying event queue is empty or until a task
// quits the loop. Once empty or quit, this method returns as opposed to
// waiting indefinitely.
void RunUntilIdle();
virtual Callback QuitClosure();
protected:
void ExecuteTask(Callback cb) {
cb();
}
// Each concrete implementation of |TaskLoop| has its own members that control
// when/on what the loop blocks, and how it is woken up. This base class has
// no members specific to the internals of the loop, besides:
// - |mutex_|: A base::Mutex
// - |queue_|: A task queue to hold base::Callbacks (tasks), since all
// |TaskLoop| implementations support task posting. Access is
// guarded by |mutex_|
// - |quit_|: A boolean set by |Quit()|. |Run()| is the only reader of this,
// meaning the thread that |this| is bound to is the only thread
// that reads this variable. |Run()| uses this in every loop
// iteration to determine, regardless of whether there are
// outstanding tasks or events to process, if the loop should stop
// running.
// - |quit_when_idle_|: A boolean set by both |RunUntilIdle()| and
// |QuitWhenIdle()|. |Run()| is the only reader of this
// variable, and it is used specifically when there are
// no tasks/events to process, to quit the loop instead
// of let it idle and wait for more tasks/events to
// process.
// Used to lock |queue_|, since it can be accessed from multiple threads via
// |PostTask()|.
base::Mutex mutex_;
std::queue<Callback> queue_;
bool quit_ = false;
bool quit_when_idle_ = false;
private:
std::weak_ptr<TaskLoop> GetWeakPtr() {
return shared_from_this();
}
};
} // namespace base
#endif // BASE_SCHEDULING_TASK_LOOP_H_
|
#ifndef WIB_LOGGING_H
#define WIB_LOGGING_H
#pragma once
namespace WhatIBuild
{
typedef void (LogFunc)(const char*);
struct LoggingCallbacks
{
LogFunc* logInfo;
LogFunc* logWarning;
LogFunc* logError;
};
class LogManager
{
public:
static void Inititalize(const LoggingCallbacks& callbacks);
static void Info(const char* text);
static void Warning(const char* text);
static void Error(const char* text);
};
}
#define WIBLOG_INFO(text) WhatIBuild::LogManager::Info( (text) );
#define WIBLOG_WARNING(text) WhatIBuild::LogManager::Warning( (text) );
#define WIBLOG_ERROR(text) WhatIBuild::LogManager::Error( (text) );
#endif // WIB_LOGGING_H
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) Opera Software ASA 2006 - 2008
*
* Web server implementation -- overall server logic
*/
#ifndef REQUEST_QUEUE_H_
#define REQUEST_QUEUE_H_
#ifdef WEBSERVER_SUPPORT
#include "modules/util/simset.h"
#include "modules/webserver/webserver_resources.h"
#include "modules/webserver/webserver_filename.h"
#include "modules/webserver/webserver_common.h"
#include "modules/webserver/webserver_callbacks.h"
#include "modules/webserver/webserver_user_management.h"
class HeaderList;
enum WebServerMethod
{
WEB_METH_GET, /* HTTP 0.9 */
WEB_METH_HEAD, /* HTTP 1.0 */
WEB_METH_POST, /* HTTP 1.0 */
WEB_METH_PUT, /* Poorly defined in HTTP 1.0 */
WEB_METH_DELETE, /* Poorly defined in HTTP 1.0 */
WEB_METH_LINK, /* Poorly defined in HTTP 1.0, not at all in HTTP 1.1 */
WEB_METH_UNLINK, /* Poorly defined in HTTP 1.0, not at all in HTTP 1.1 */
WEB_METH_TRACE, /* HTTP 1.1 */
WEB_METH_CONNECT, /* HTTP 1.1 */
WEB_METH_OPTIONS, /* HTTP 1.1 */
WEB_METH_NONE_ERROR /* In case of error*/
};
class WebserverRequest : public Link, private WebserverFileName, private AddToCollectionCallback
{
public:
WebserverRequest();
~WebserverRequest();
/* Constructs a requests from resource (for example index.html), headerlist and method
*
*
* @param resource Path and name of the resource requested
* @param resourceStringLength Length of the resource string
* @param clientHeaderList The headerlist in the request.
* @param httpMethod The method (like GET, POST etc).
*
* @return OpStatus::ERR_NO_MEMORY If OOM.
* OpStatus::ERR If the function has been called before on this object.
* OpStatus::OK For sucess
*
*/
OP_STATUS Construct(const char *resource, int resourceStringLength, HeaderList *clientHeaderList, WebServerMethod httpMethod, BOOL isProxied);
/* Copy a request. Note that response headers are NOT copied.
*
* @param original Request to Copy.
*
* @return OpStatus::ERR_NO_MEMORY or OpStatus::OK.
*
*/
OP_STATUS Copy(WebserverRequest *original);
/* Reconstructs the this request
*
* If the subserver name is changed after this reconstruct, GetSubServerNameEditedState() will
* return TRUE
*
* @param resource The resource that is requested.
* @param resourceStringLength Length of resource string
* @param clientHeaderList Client header list.
*
* @param return OpStatus::ERR_NO_MEMORY or OpStatus::OK
*/
OP_STATUS Reconstruct(const char *resource, int resourceStringLength, HeaderList *clientHeaderList = NULL);
static OP_STATUS UrlEncodeString(const OpStringC &uri, OpString &encoded_uri);
/* Returns the request string. This path has been normalized and
* checked for /../.
*
* @return the normalized path. */
const uni_char *GetRequest();
/* Returns the request path to subserver (the path after /subserver/...
* This path has been normalized and checked for /../.
*
* @return the normalized path. */
const uni_char *GetSubServerRequest();
OP_STATUS GetEscapedRequest(OpString &request);
/* Returns the orignal URI as sent by the client
*
* NOTE! The original request uri is not checked
* for dangerous paths.
* MUST never be used in file operations.
*
* @param return The original request uri
*/
const char *GetOriginalRequest();
const uni_char *GetOriginalRequestUni();
/* Get the header list.
*
* @return List of headers sent by the client.
*/
HeaderList *GetClientHeaderList();
/* Get the http method.
*
* @return The method of this request
*/
WebServerMethod GetHttpMethod();
/* Get the proxy state.
*
* @return TRUE when request was proxied
*/
BOOL IsProxied() { return m_isProxied; }
/* Get the forward state.
*
* If this is set to TRUE, javascript will not handle this request,
* but will forward to any other resource that listen to this request.
*/
BOOL GetForwardRequestState(){ return m_forwardRequestState; }
/* Check if the subserver name has been changed in a call to Reconstruct(..)
*
* @return TRUE if Reconstruct changed the subserver name.
*/
BOOL GetSubServerNameEditedState() { return m_subServerVirtualPathEdited; }
/* Get a unique ID for this request
*
* @return a unique ID.
*/
UINT GetRequestId(){ return m_requstId; }
/* Get the path of the sub server for this request.
* Trailing and prepending slashes are not included.
*
* @return The path of the subserver. */
const uni_char* GetSubServerVirtualPath(){ return m_subServerVirtualPath.CStr(); }
OP_BOOLEAN GetItemInQuery(const uni_char *item, OpString &value, unsigned int &index, BOOL unescape);
OP_STATUS GetAllItemsInQuery(OpStringHashTable<OpAutoStringVector> &item_collection, BOOL unescape);
BOOL UserAuthenticated() { return GetAuthenticatedUsername() ? TRUE : FALSE; }
const uni_char* GetAuthenticatedUsername() { return m_authenticated_user.CStr(); }
/* Do not save this pointer. It might be deleted at any time */
WebserverAuthSession *GetAuthSession() { return g_webserverUserManager->GetAuthSessionFromSessionId(m_session_id); }
const uni_char *GetSessionId(){ return m_session_id.CStr(); }
OP_STATUS DetectAuthenticationType(WebSubServerAuthType &type);
private:
OP_STATUS AddToCollection(const uni_char* key, const uni_char* dataString);
/* Insert a list of response headers. Should only be used when re-issuing a request.
*
* @param headers The list of headers to be inserted, this object takes ownership of the items.
*
* @return return OpStatus::ERR_NO_MEMORY or OpStatus::OK.
*/
OP_STATUS SetResponseHeaders(Header_List &headers);
BOOL RequestHadSessionCookie() { return m_had_session_cookie; }
OP_STATUS SetupSessionId();
void SetResponseCode(int responseCode) { m_responseCode = responseCode; }
int GetResponseCode() { return m_responseCode; }
BOOL HasResponseHeaders();
void TakeOverResponseHeaders(Header_List &headers);
OP_STATUS GetSubServerName(const char *request, int requestStringLength, OpString &subServerName);
void SetForwardRequestState(BOOL forwardRequest) { m_forwardRequestState = forwardRequest;}
void SetAuthStatus(BOOL hasAuthenticated) { m_auth_status = hasAuthenticated; }
BOOL HasAuthenticated() { return m_auth_status; }
OP_STATUS ReconstructOverrideSecurity(const char *resource, int resourceStringLength, HeaderList *clientHeaderList, BOOL overrideSecurity);
/* This is the original request uri. This must only be used of authentication since the path might be malicous. */
OpString8 m_originalRequestURI;
OpString16 m_uniOriginalRequestURI;
/* The path that identifies a subserver. Trailing and prepending slashes are not included. */
OpString16 m_subServerVirtualPath;
OpString16 m_authenticated_user;
OpString m_session_id;
OpString m_session_auth;
WebServerMethod m_httpMethod;
HeaderList *m_clientHeaderList;
/* If the request has been reissued (ReIssueRequest(), or closeAndRedispatch() in Javascript), we will remember the reponse headers */
Header_List m_responseHeaderList;
BOOL m_forwardRequestState;
BOOL m_subServerVirtualPathEdited;
BOOL m_auth_status;
BOOL m_isProxied;
UINT m_requstId;
int m_responseCode;
BOOL m_had_session_cookie;
OpStringHashTable<OpAutoStringVector> *m_temp_item_collection; /* Not owned by this object */
friend class WebResource_Auth;
friend class WebResource;
friend class WebServerConnection;
};
#endif // WEBSERVER_SUPPORT
#endif /*REQUEST_QUEUE_H_*/
|
/* Copyright 2016 tgil All Rights Reserved */
#ifndef UI_BUTTONPIN_HPP_
#define UI_BUTTONPIN_HPP_
#include "../hal/Pin.hpp"
#include "Button.hpp"
namespace ui {
/*! \brief Button Pin Class
* \details This class implements a button using a hal::Pin object.
*/
class ButtonPin : public Button, public hal::Pin {
public:
/*! \details Construct a new ButtonPin
*
* The pin must be initialized using Pin::init()
*
* @param port The port associated with the pin
* @param pin The pin number on the port for the button input
* @param active_value true for active high and false for active low
*/
ButtonPin(int port, int pin, bool active_value = true);
/*! \details This method accesses the active value.
*
* @return True for active high and false for active low.
*/
bool active_value() const { return m_active_value; }
private:
bool get_is_active() const;
bool m_active_value;
};
};
#endif /* UI_BUTTONPIN_HPP_ */
|
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cmath>
#include <string>
#include <cstring>
#include <queue>
#include <vector>
#include <set>
#include <deque>
#include <map>
#include <functional>
#include <numeric>
#include <sstream>
#include <complex>
typedef long double LD;
typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned int uint;
#define PI 3.1415926535897932384626433832795
#define sqr(x) ((x)*(x))
using namespace std;
int a[111111];
int main() {
// freopen(".in", "r", stdin);
// freopen(".out", "w", stdout);
int n, mx = 0;
scanf("%d", &n);
for (int i =0 ; i < n; ++i) {
scanf("%d", &a[i]);
mx = max(mx, a[i]);
}
ULL left = mx;
ULL right = mx + mx;
while (left < right) {
ULL c = (right + left) >> 1, v = 0;
for (int i = 0; i < n; ++i) {
if (c > a[i]) v += c - a[i];
}
if (v >= c) right = c;else left = c + 1;
}
cout << left << endl;
return 0;
}
|
#pragma once
#include <Poco/Util/AbstractConfiguration.h>
#include "util/FileLoader.h"
#include "util/Loggable.h"
namespace Poco {
class File;
class Path;
}
namespace BeeeOn {
class ConfigurationLoader : public FileLoader, public Loggable {
public:
ConfigurationLoader();
virtual ~ConfigurationLoader();
void load(const Poco::File &file) override;
virtual void load(const Poco::Path &path);
void finished() override;
Poco::AutoPtr<Poco::Util::AbstractConfiguration> config() const;
private:
Poco::AutoPtr<Poco::Util::AbstractConfiguration> m_config;
};
}
|
/*
Copyright (c) 2016, Los Alamos National Security, LLC
All rights reserved.
Copyright 2016. Los Alamos National Security, LLC. This software was produced under U.S. Government contract DE-AC52-06NA25396 for Los Alamos National Laboratory (LANL), which is operated by Los Alamos National Security, LLC for the U.S. Department of Energy. The U.S. Government has rights to use, reproduce, and distribute this software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to produce derivative works, such modified software should be clearly marked, so as not to confuse it with the version available from LANL.
Additionally, redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of Los Alamos National Security, LLC, Los Alamos National Laboratory, LANL, the U.S. Government, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY LOS ALAMOS NATIONAL SECURITY, LLC AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LOS ALAMOS NATIONAL SECURITY, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef BoundaryConditions_hpp
#define BoundaryConditions_hpp
#include <stdio.h>
#include <array>
#include <cmath>
#include "AbstractSystem.hpp"
#include "Constants.hpp"
inline static std::pair<std::array<double, NDIM>, std::array<double, NDIM> > primaryCellPosition(std::array<double, NDIM> &r, Cell &cell){
std::array<double, NDIM> s;
for(int i=0; i<NDIM; i++) {
r[i]-=cell.origin[i];
}
//project to cell-space
for(int i=0; i<NDIM; i++) {
s[i]=0;
for(int j=0; j<NDIM; j++) {
s[i]+=cell.csp[i][j]*r[j];
}
}
//wrap if necessary
for(int i=0; i<NDIM; i++) {
s[i]-=floor(s[i])*cell.periodic[i];
}
//project to R-space
for(int i=0; i<NDIM; i++) {
r[i]=0;
for(int j=0; j<NDIM; j++) {
r[i]+=cell.rsp[i][j]*s[j];
}
r[i]+=cell.origin[i];
}
return std::make_pair(r,s);
};
inline static std::pair<std::array<double, NDIM>, std::array<double, NDIM> > primaryCellPosition(int iAtom, AbstractSystem &system){
Cell &c=system.cell;
std::array<double, NDIM> s;
std::array<double, NDIM> r;
for(int i=0; i<NDIM; i++) {
r[i]=system.getPosition(iAtom,i);
}
return primaryCellPosition(r,c);
};
inline static double nearestImageDistance(int iAtom, int jAtom, AbstractSystem &system, Cell &cell){
double r2=0;
std::array<double, NDIM> ds;
std::array<double, NDIM> dr;
//obtain the distance in R-space
for(int i=0; i<NDIM; i++) {
dr[i]=system.getPosition(iAtom,i)-system.getPosition(jAtom,i);
}
//project to cell-space
for(int i=0; i<NDIM; i++) {
ds[i]=0;
for(int j=0; j<NDIM; j++) {
ds[i]+=cell.csp[i][j]*dr[j];
}
}
//wrap if necessary (where allowed)
for(int i=0; i<NDIM; i++) {
ds[i]-=round(ds[i])*cell.periodic[i];
}
//project to R-space
r2=0;
for(int i=0; i<NDIM; i++) {
dr[i]=0;
for(int j=0; j<NDIM; j++) {
dr[i]+=cell.rsp[i][j]*ds[j];
}
r2+=dr[i]*dr[i];
}
return sqrt(r2);
};
inline static double nearestImageDistance(std::array<double, NDIM> positions, int jAtom, AbstractSystem &system, Cell &cell){
double r2=0;
std::array<double, NDIM> ds;
std::array<double, NDIM> dr;
//obtain the distance in R-space
for(int i=0; i<NDIM; i++) {
dr[i]=positions[i]-system.getPosition(jAtom,i);
}
//project to cell-space
for(int i=0; i<NDIM; i++) {
ds[i]=0;
for(int j=0; j<NDIM; j++) {
ds[i]+=cell.csp[i][j]*dr[j];
}
}
//wrap if necessary (where allowed)
for(int i=0; i<NDIM; i++) {
ds[i]-=round(ds[i])*cell.periodic[i];
}
//project to R-space
r2=0;
for(int i=0; i<NDIM; i++) {
dr[i]=0;
for(int j=0; j<NDIM; j++) {
dr[i]+=cell.rsp[i][j]*ds[j];
}
r2+=dr[i]*dr[i];
}
return sqrt(r2);
};
#endif /* BoundaryConditions_hpp */
|
/*
* Copyright (c) 2015-2018 Morwenn
* SPDX-License-Identifier: MIT
*/
#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
|
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int n, m, k;
int S[1111][1111];
int mx = 0, maxc = 0;
int main() {
freopen("bread.in", "r", stdin);
freopen("bread.out", "w", stdout);
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
for (int j = x1; j < x2; ++j) {
++S[j][y1];
--S[j][y2];
}
}
for (int i = 0; i < n; ++i) {
int cur = 0;
for (int j = 0; j < m; ++j) {
cur += S[i][j];
if (cur > mx) {
mx = cur;
maxc = 1;
} else if (cur == mx) {
++maxc;
}
}
}
printf("%d\n%d\n", mx, maxc);
return 0;
}
|
#include <fstream>
#include <iostream>
#include <cstring>
#include <vector>
#include <regex>
enum DelimiterTypes {
begin, begin_print, end
};
void run(std::istream &in, std::ostream &out, std::vector<std::string> delimiters = {"<%", "=", "%>"}) {
out << "#ifndef OUT" << std::endl;
out << "#define OUT out" << std::endl;
out << "#define TMP_OUT" << std::endl;
out << "#endif" << std::endl;
out << "{" << std::endl; // separate scope for the file
std::string buf;
in >> std::noskipws;
char c;
bool code_active = false;
bool print_active = false;
while (in >> c) {
if (!code_active && !print_active) {
if (c == '\n') {
buf += "\\n";
} else if (c == '"') {
buf += "\\\"";
} else if (c == '\\') {
buf += "\\\\";
} else {
buf.push_back(c);
}
} else {
buf.push_back(c);
}
for (int type = 0; type < 3; ++type) {
std::string &delim = delimiters[type];
// Prevents mathcing normal = inside code
if (type == begin_print && buf.size() != delim.size()) continue;
bool match = false;
if (
buf.size() >= delim.size() &&
buf.compare(buf.size()-delim.size(), delim.size(), delim) == 0
) {
match = true;
}
// Tag escaping
if (match && buf.size() > delim.size() && buf[buf.size()-delim.size()-1] == '\\') {
match = false;
// Turn into literal tag
if (code_active || print_active) {
buf.resize(buf.size()-delim.size()-1);
} else {
// The \ was duplicated earlier...
buf.resize(buf.size()-delim.size()-2);
}
buf += delim;
}
if (match) {
switch (type) {
case begin:
if (code_active || print_active) break;
buf.resize(buf.size()-delim.size());
code_active = true;
out << "OUT << u8\"" << buf << "\";" << std::endl;
buf.clear();
break;
case begin_print:
if (!code_active || print_active) break;
code_active = false;
print_active = true;
buf.clear();
break;
case end:
buf.resize(buf.size()-delim.size());
if (code_active) {
code_active = false;
out << buf << std::endl << ";";
buf.clear();
} else if (print_active) {
print_active = false;
out << "OUT << (" << buf << ");" << std::endl;
buf.clear();
}
break;
}
// Don't look for other tags anymore
break;
}
}
}
// Print rest of file
out << "OUT << u8\"" << buf << "\";" << std::endl;
buf.clear();
// Close the scope
out << "}" << std::endl;
out << "#ifdef TMP_OUT" << std::endl;
out << "#undef OUT" << std::endl;
out << "#undef TMP_OUT" << std::endl;
out << "#endif" << std::endl;
}
int main(int argc, char *argv[]) {
if (argc < 2) {
std::cerr << "Please specify files to parse (or --)." << std::endl;
return 1;
}
bool dnext = false;
bool dset = false;
std::vector<std::string> d;
for (int vi = 1; vi < argc; ++vi) {
std::string arg = argv[vi];
if (dnext) {
dnext = false;
dset = true;
d.clear();
d.push_back("");
for (char c : arg) {
if (c == ' ') {
d.push_back("");
} else {
d.back().push_back(c);
}
}
continue;
} else if (arg == "-d" || arg == "--delimiters") {
dnext = true;
} else if (arg == "--") {
if (dset) run(std::cin, std::cout, d);
else run(std::cin, std::cout);
} else {
std::ifstream in(arg);
std::ofstream out(arg + ".cpp");
if (dset) run(in, out, d);
else run(in, out);
}
}
}
|
#include<cstdio>
#include<algorithm>
#include <iostream>
#include<cstring>
using namespace std;
#define N 2500
#define INF 0xfffffff
typedef long long ll;
ll dp[N][N][2];
ll n,V,X;
ll sum[N];
struct node
{
ll x;
ll v;
} a[N];
ll cmp(node b,node c)
{
return b.x<c.x;
}
ll Delay(ll l,ll r)
{
if(l>r)
return 0;
return sum[r]-sum[l-1];
}
void DP()
{
ll res;
for(ll i=1; i<=n; i++)
{
for(ll j=1; j<=n; j++)
dp[i][j][0]=dp[i][j][1]=INF;
}
for(ll i=1; i<=n; i++)
{
if(a[i].x==X)
{
res=i;
break;
}
}
dp[res][res][0]=dp[res][res][1]=0;
for(ll i=res; i>=1; i--)//iŃ»·restaurant×ó±ßµÄ
{
for(ll j=res; j<=n; j++)//jŃ»·restaurantÓұߵÄ
{
ll delay=Delay(1,i-1)+Delay(j+1,n);
if(i==j)
continue;
dp[i][j][0]=min(dp[i][j][0],dp[i+1][j][0]+(a[i+1].x-a[i].x)*(delay+a[i].v));
dp[i][j][0]=min(dp[i][j][0],dp[i+1][j][1]+(a[j].x-a[i].x)*(delay+a[i].v));
dp[i][j][1]=min(dp[i][j][1],dp[i][j-1][0]+(a[j].x-a[i].x)*(delay+a[j].v));
dp[i][j][1]=min(dp[i][j][1],dp[i][j-1][1]+(a[j].x-a[j-1].x)*(delay+a[j].v));
}
}
}
int main()
{
freopen("data.in","r",stdin);
while(scanf("%d%d%d",&n,&V,&X)!=EOF)
{
for(int i=1; i<=n; i++)
{
scanf("%d%d",&a[i].x,&a[i].v);
}
a[n+1].x=X;
a[n+1].v=0;
n++;
sort(a+1,a+n+1,cmp);
memset(sum,0,sizeof(sum));
for(int i=1; i<=n; i++)
sum[i]=sum[i-1]+a[i].v;
DP();
printf("%d\n",min(dp[1][n][0],dp[1][n][1])/V);
}
return 0;
}
|
//#include "DetectorConstruction.hh"
#include "SCENE_TwoPhasePrototype_CoincidentGeometry.hh"
#include "BeamTestSensitiveDetector.hh"
#include "PeripherySensitiveDetector.hh"
#include "G4Polyhedra.hh"
#include "G4Polycone.hh"
#include "G4Tubs.hh"
#include "G4Transform3D.hh"
#include "G4RotationMatrix.hh"
#include "G4Box.hh"
#include "G4Colour.hh"
#include "G4LogicalVolume.hh"
#include "G4Material.hh"
#include "G4NistManager.hh"
#include "G4PVParameterised.hh"
#include "G4PVPlacement.hh"
#include "G4RunManager.hh"
#include "G4Tubs.hh"
#include "G4SubtractionSolid.hh"
#include "G4UnionSolid.hh"
#include "G4VisAttributes.hh"
#include "G4SDManager.hh"
#include "stdlib.h"
#include "string.h"
#include <cmath>
DetectorConstruction::DetectorConstruction()
:fpWorldLogical(0)
,fpWorldPhysical(0)
{}
DetectorConstruction::~DetectorConstruction() {}
G4VPhysicalVolume*DetectorConstruction::Construct()
{
// Material Definition
DefineMaterials();
// Geometry Definition
SetupGeometry();
// Return world volume
return fpWorldPhysical;
}
void DetectorConstruction::DefineMaterials()
{
G4String symbol;
G4double a, z, density;
G4int ncomponents;
G4double fractionmass;
//================================== elements ===================================
new G4Material( "Silicon", z=14., a=28.0855*g/mole, density=2.330*g/cm3);
new G4Material( "Iron", z=26., a=55.845*g/mole, density=7.87*g/cm3);
new G4Material( "Titanium", z=22., a=47.90*g/mole, density=4.540*g/cm3);
new G4Material( "LiquidArgon", z=18, a=39.948*g/mole, density=1.43*g/cm3);
new G4Material( "GasArgon", z=18, a=39.948*g/mole, density=1.449e-3*g/cm3);
new G4Material( "Copper", z=29, a=63.546*g/mole, density=8.94*g/cm3);
new G4Material( "Aluminium", z=13, a=26.98*g/mole, density=2.70*g/cm3);
new G4Material( "Tungsten", z=74, a=183.85*g/mole, density=19.25*g/cm3);
G4Element *H = new G4Element("Hydrogen", "H", 1., 1.0079*g/mole);
G4Element *C = new G4Element("Carbon", "C", 6., 12.011*g/mole);
G4Element *N = new G4Element("Nitrogen", "N", 7., 14.007*g/mole);
G4Element *O = new G4Element("Oxygen", "O", 8., 15.999*g/mole);
G4Element *F = new G4Element("Fluorine", "F", 9., 18.998*g/mole);
G4Element *Si = new G4Element("Silicon", "Si", 14., 28.086*g/mole);
G4Element *Cr = new G4Element("Chromium", "Cr", 24., 51.996*g/mole);
G4Element *Mn = new G4Element("Manganese", "Mn", 25., 54.938*g/mole);
G4Element *Fe = new G4Element("Iron", "Fe", 26., 55.85*g/mole); //-- density 7.874*g/cm3 --
G4Element *Ni = new G4Element("Nickel", "Ni", 28., 58.693*g/mole); //-- density 8.9*g/cm3 --
G4Element *Mo = new G4Element("Nickel", "Ni", 42., 95.96*g/mole); //-- density 10.28*g/cm3 --
//G4Element *Al = new G4Element("Aluminium", "Al", 13., 26.982*g/mole);
//G4Element *Xe = new G4Element("Xenon", "Xe", 54., 131.293*g/mole);
//G4Element *Cu = new G4Element("Copper", "Cu", 29., 63.546*g/mole);
//G4Element *Pb = new G4Element("Lead", "Pb", 82., 207.2*g/mole);
//G4Element *Gd = new G4Element("Gadolinium","Gd", 64., 157.25*g/mole);
// PTFE
G4Material* Teflon = new G4Material("Teflon", 2.2*g/cm3, 2, kStateSolid);
Teflon->AddElement(C, 0.240183);
Teflon->AddElement(F, 0.759817);
// polyethylene
G4Material* polyethylene = new G4Material("polyethylene", 0.94*g/cm3, 2, kStateSolid);
polyethylene->AddElement(C, 1);
polyethylene->AddElement(H, 2);
// paraffin
G4Material* paraffin = new G4Material("paraffin", 0.9*g/cm3, 2, kStateSolid);
paraffin->AddElement(C, 1);
paraffin->AddElement(H, 2);
// quartz
G4Material* quartz = new G4Material("quartz", 2.201*g/cm3, 2, kStateSolid);
quartz->AddElement(Si, 1);
quartz->AddElement(O, 2);
// Stainless Steel
G4Material *SS304LSteel = new G4Material("SS304LSteel", 8.00*g/cm3, 5, kStateSolid);
SS304LSteel->AddElement(Fe, 0.65);
SS304LSteel->AddElement(Cr, 0.20);
SS304LSteel->AddElement(Ni, 0.12);
SS304LSteel->AddElement(Mn, 0.02);
SS304LSteel->AddElement(Si, 0.01);
// False Stainless Steel
G4Material *SS_Pole = new G4Material("SS_Pole", 0.80*g/cm3, 5, kStateSolid);
SS_Pole->AddElement(Fe, 0.65);
SS_Pole->AddElement(Cr, 0.20);
SS_Pole->AddElement(Ni, 0.12);
SS_Pole->AddElement(Mn, 0.02);
SS_Pole->AddElement(Si, 0.01);
// 316L Steel
G4Material *SS316LSteel = new G4Material("SS316LSteel", 7000/12.7/51.6/5.5*g/cm3, 5, kStateSolid); //-- Heat Exchanger 127W x 516H x 55D-----
SS316LSteel->AddElement(Fe, 0.67);
SS316LSteel->AddElement(Cr, 0.17);
SS316LSteel->AddElement(Ni, 0.12);
SS316LSteel->AddElement(Mn, 0.02);
SS316LSteel->AddElement(Mo, 0.02);
// special Kovar (Co free material), the 3" PMT Shell Material, based on assumption of 8.35*g/cm3 and two components Fe and Ni only
// -- x+y=1--
// -- 7.874*x + 8.9*y = 8.35 --
G4Material *Kovar = new G4Material("Kovar",8.35*g/cm3, 2, kStateSolid);
Kovar->AddElement(Ni, 0.464);
Kovar->AddElement(Fe, 0.536);
//EJ301 (the liquid scintillator for neutron detector)
G4Material* EJ301 = new G4Material("EJ301", density=0.874*g/cm3, 2, kStateLiquid);
EJ301->AddElement(H, 0.548);
EJ301->AddElement(C, 0.452);
// Air
G4Material* Air = new G4Material("Air", density= 1.290*mg/cm3, ncomponents=2);
Air->AddElement(N, fractionmass=0.7);
Air->AddElement(O, fractionmass=0.3);
// Define vacuum
G4Material* Vacuum = new G4Material("Vacuum", density= 1.e-5*g/cm3, ncomponents=1, kStateGas, STP_Temperature, 2.e-7*bar);
Vacuum->AddMaterial(Air, fractionmass=1.);
// Dump material information
//G4cout << *(G4Material::GetMaterialTable()) << G4endl;
}
void DetectorConstruction::SetupGeometry()
{
G4Material* air = G4Material::GetMaterial("Air");
G4Material* LAr = G4Material::GetMaterial("LiquidArgon");
G4Material* GAr = G4Material::GetMaterial("GasArgon");
G4Material* Al = G4Material::GetMaterial("Aluminium");
G4Material* quartz = G4Material::GetMaterial("quartz");
G4Material* EJ301 = G4Material::GetMaterial("EJ301");
G4Material* PTFE = G4Material::GetMaterial("Teflon");
G4Material* steel = G4Material::GetMaterial("SS304LSteel");
G4Material* pole_steel = G4Material::GetMaterial("SS_Pole");
G4Material* vacuum = G4Material::GetMaterial("Vacuum");
G4Material* polyethylene = G4Material::GetMaterial("polyethylene");
G4Material* paraffin = G4Material::GetMaterial("paraffin");
G4Material* copper = G4Material::GetMaterial("Copper");
G4Material* Kovar = G4Material::GetMaterial("Kovar");
G4Material* SS316L = G4Material::GetMaterial("SS316LSteel");
G4Material* Tungsten = G4Material::GetMaterial("Tungsten");
/* //--- Cylindral world volume-----
G4double world_Radius = 3*m;
G4double world_halfHeight = 1.5*m;
G4Tubs* worldSolid = new G4Tubs("World_Solid", 0*m, world_Radius, world_halfHeight, 0*deg, 360*deg);
fpWorldLogical = new G4LogicalVolume(worldSolid, air, "World_Logical");
fpWorldPhysical = new G4PVPlacement(0, G4ThreeVector(), fpWorldLogical, "World_Physical", 0, false, 0);
*/
G4double world_halfLength = 3*m;
G4Box* worldSolid = new G4Box("World_Solid", world_halfLength, world_halfLength, world_halfLength);
fpWorldLogical = new G4LogicalVolume(worldSolid, vacuum, "World_Logical");
fpWorldPhysical = new G4PVPlacement(0, G4ThreeVector(), fpWorldLogical, "World_Physical", 0, false, 0);
//---------------------------------------------
/*
Geometry Description on LAr TPC and EJ301.
1. the z=0 plane is set to liquid/gas interface
April 11th
1. PE collimator is added in geometry.
2. in particle gun setting, neutron is 50cm away from origion.
3. particle gun offset in zAxis is 38cm. (total length of field cage is 76cm)
4. PE collimator is set to 3cm away from neutron beam.
May 30th
1. The SS dewar and flange geometry are based on FNAL design.
2. Coldhead and heat exchanger are also added.
Nov. 2nd
The Center of InnerSSDewar is the Origion (0, 0, 0)
OuterSSDewar location is based on the SSHoldingBar length.
Coldhead is moved 15*mm in xAxis direction to avoid overlap with heat exchanger
Nov. 28th
#1. change the distance btw LiF & TPC center to 58 cm
#2. for 90-deg scattering case, change the distance btw TPC center and EJ301 active volume center to 58 cm
#3. adjust the LiF right to the PE collimator (no distance in between)
#4. From upper surface of the bottom quartz window to the bottom flange is 1 foot.
*/
//---------------------------------------------
// the Stainless Steel Color
//G4VisAttributes* SS_Color = new G4VisAttributes(G4Colour::Black());
G4VisAttributes* SS_Color = new G4VisAttributes(G4Colour(0.2, 0.2, 0.2, 1.0));
SS_Color->SetForceSolid(true);
// the Aluminum Frame Color
//G4VisAttributes* Al_Color = new G4VisAttributes(G4Colour::Black());
G4VisAttributes* Al_Color = new G4VisAttributes(G4Colour(0.4, 0.4, 0.4, 0.));
Al_Color->SetForceSolid(true);
// Color for EJs
//G4VisAttributes* EJColor = new G4VisAttributes(G4Colour(0.1,0.8,0.1,0.1));
//EJColor->SetForceSolid(false);
//EJColor->SetForceWireframe(false);
//----------- SS Dewar and flange --------------
//--- InnerDewar ---
const G4double SSInnerDewar_OuterRadius = 4/2*25.4*mm; //-- 4" OD---
const G4double SSInnerDewar_Thickness = 0.065*25.4*mm; //-- 0.065"---
const G4double SSInnerDewar_TotHeight = 30*25.4*mm; //-- 30" height---
//---CF600 Flange---
const G4double SSInnerDewar_CF600Flange_OuterRadius = 5.97/2*25.4*mm; //-- 6" OD --
const G4double SSInnerDewar_CF600Flange_TotHeight = 0.78*25.4*mm; //-- 0.78" thick --
//--- OuterDewar ---
const G4double SSOuterDewar_OuterRadius = 14/2*25.4*mm; //-- 14" OD --
const G4double SSOuterDewar_Thickness = 0.188*25.4*mm; //-- 0.188" thick --
const G4double SSOuterDewar_TotHeight = 6*12*25.4*mm; //-- 6' long --
//--- CF1650 Flange ---
const G4double SSOuterDewar_CF1650Flange_OuterRadius = 16.5/2*25.4*mm; //-- 16.5" OD --
const G4double SSOuterDewar_CF1650Flange_TotHeight = 1.12*25.4*mm;
//--- SS bar 1” X 0.75” X 29” ---
const G4double DewarHoldingBar_Height = 29*25.4*mm;
const G4double DewarHoldingBar_Width = 1*25.4*mm;
const G4double DewarHoldingBar_Long = 0.75*25.4*mm;
//--- Relative Location parameters ---
const G4double SSInnerDewar_xCenterPosition = 0*mm;
const G4double SSInnerDewar_yCenterPosition = 0*mm;
const G4double SSInnerDewar_zCenterPosition = 0*mm;
const G4double SSOuterDewar_xCenterPosition = 0*mm;
const G4double SSOuterDewar_yCenterPosition = 0*mm;
const G4double SSOuterDewar_zCenterPosition = SSInnerDewar_TotHeight/2 + DewarHoldingBar_Height - SSOuterDewar_TotHeight/2;
const G4double HoldingBar_xPosition = SSInnerDewar_xCenterPosition + 0.*mm;
const G4double HoldingBar_yPosition = SSInnerDewar_yCenterPosition + SSInnerDewar_CF600Flange_OuterRadius + DewarHoldingBar_Long/2;
const G4double HoldingBar_zPosition = SSInnerDewar_zCenterPosition + SSInnerDewar_TotHeight/2 + DewarHoldingBar_Height/2;
G4Tubs *SSInnerDewar_CF600Flange = new G4Tubs("SSInnerDewar_CF600Flange", 0.*mm, SSInnerDewar_CF600Flange_OuterRadius, SSInnerDewar_CF600Flange_TotHeight/2, 0.*deg, 360*deg);
G4Tubs *SSOuterDewar_CF1650Flange = new G4Tubs("SSOuterDewar_CF1650Flange", 0.*mm, SSOuterDewar_CF1650Flange_OuterRadius, SSOuterDewar_CF1650Flange_TotHeight/2, 0.*deg, 360*deg);
G4LogicalVolume *SSInnerDewar_CF600Flange_Logical = new G4LogicalVolume(SSInnerDewar_CF600Flange, steel, "SSInnerDewar_CF600Flange_Logical");
G4LogicalVolume *SSInnerDewar_CF1650Flange_Logical = new G4LogicalVolume(SSOuterDewar_CF1650Flange, steel, "SSInnerDewar_CF1650Flange_Logical");
new G4PVPlacement(0, G4ThreeVector(SSInnerDewar_xCenterPosition, SSInnerDewar_yCenterPosition, (SSInnerDewar_zCenterPosition+SSInnerDewar_TotHeight/2+SSInnerDewar_CF600Flange_TotHeight/2)), SSInnerDewar_CF600Flange_Logical, "SSInnerDewar Top CF600Flange Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(SSInnerDewar_xCenterPosition, SSInnerDewar_yCenterPosition, (SSInnerDewar_zCenterPosition-SSInnerDewar_TotHeight/2-SSInnerDewar_CF600Flange_TotHeight/2)), SSInnerDewar_CF600Flange_Logical, "SSInnerDewar Bottom CF600Flange Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(SSOuterDewar_xCenterPosition, SSOuterDewar_yCenterPosition, (SSOuterDewar_zCenterPosition+SSOuterDewar_TotHeight/2+SSOuterDewar_CF1650Flange_TotHeight/2)), SSInnerDewar_CF1650Flange_Logical, "SSInnerDewar Top CF1650Flange Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(SSOuterDewar_xCenterPosition, SSOuterDewar_yCenterPosition, (SSOuterDewar_zCenterPosition-SSOuterDewar_TotHeight/2-SSOuterDewar_CF1650Flange_TotHeight/2)), SSInnerDewar_CF1650Flange_Logical, "SSInnerDewar Bottom CF1650Flange Physical", fpWorldLogical, true, 1, true);
//SSInnerDewar_CF600Flange_Logical->SetVisAttributes(G4Colour::Grey());
//SSInnerDewar_CF1650Flange_Logical->SetVisAttributes(G4Colour::Grey());
SSInnerDewar_CF600Flange_Logical->SetVisAttributes(SS_Color);
SSInnerDewar_CF1650Flange_Logical->SetVisAttributes(SS_Color);
G4Tubs *SSInnerDewar_CF600FlangeRing = new G4Tubs("SSInnerDewar_CF600FlangeRing", SSInnerDewar_OuterRadius, SSInnerDewar_CF600Flange_OuterRadius, SSInnerDewar_CF600Flange_TotHeight/2, 0.*deg, 360*deg);
G4Tubs *SSOuterDewar_CF1650FlangeRing = new G4Tubs("SSOuterDewar_CF1650FlangeRing", SSOuterDewar_OuterRadius, SSOuterDewar_CF1650Flange_OuterRadius, SSOuterDewar_CF1650Flange_TotHeight/2, 0.*deg, 360*deg);
G4LogicalVolume *SSInnerDewar_CF600FlangeRing_Logical = new G4LogicalVolume(SSInnerDewar_CF600FlangeRing, steel, "SSInnerDewar_CF600FlangeRing_Logical");
G4LogicalVolume *SSOuterDewar_CF1650FlangeRing_Logical = new G4LogicalVolume(SSOuterDewar_CF1650FlangeRing, steel, "SSOuterDewar_CF1650FlangeRing_Logical");
new G4PVPlacement(0, G4ThreeVector(SSInnerDewar_xCenterPosition, SSInnerDewar_yCenterPosition, (SSInnerDewar_zCenterPosition+SSInnerDewar_TotHeight/2-SSInnerDewar_CF600Flange_TotHeight/2)), SSInnerDewar_CF600FlangeRing_Logical, "SSInnerDewar Top CF600FlangeRing Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(SSInnerDewar_xCenterPosition, SSInnerDewar_yCenterPosition, (SSInnerDewar_zCenterPosition-SSInnerDewar_TotHeight/2+SSInnerDewar_CF600Flange_TotHeight/2)), SSInnerDewar_CF600FlangeRing_Logical, "SSInnerDewar Bottom CF600FlangeRing Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(SSOuterDewar_xCenterPosition, SSOuterDewar_yCenterPosition, (SSOuterDewar_zCenterPosition+SSOuterDewar_TotHeight/2-SSOuterDewar_CF1650Flange_TotHeight/2)), SSOuterDewar_CF1650FlangeRing_Logical, "SSOuterDewar Top CF1650FlangeRing Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(SSOuterDewar_xCenterPosition, SSOuterDewar_yCenterPosition, (SSOuterDewar_zCenterPosition-SSOuterDewar_TotHeight/2+SSOuterDewar_CF1650Flange_TotHeight/2)), SSOuterDewar_CF1650FlangeRing_Logical, "SSOuterDewar Bottom CF1650FlangeRing Physical", fpWorldLogical, true, 1, true);
//SSInnerDewar_CF600FlangeRing_Logical->SetVisAttributes(G4Colour::Grey());
//SSOuterDewar_CF1650FlangeRing_Logical->SetVisAttributes(G4Colour::Grey());
SSInnerDewar_CF600FlangeRing_Logical->SetVisAttributes(SS_Color);
SSOuterDewar_CF1650FlangeRing_Logical->SetVisAttributes(SS_Color);
G4Tubs *SSInnerDewar = new G4Tubs("SSInnerDewar", SSInnerDewar_OuterRadius-SSInnerDewar_Thickness, SSInnerDewar_OuterRadius, SSInnerDewar_TotHeight/2, 0.*deg, 360*deg);
G4Tubs *SSOuterDewar = new G4Tubs("SSOuterDewar", SSOuterDewar_OuterRadius-SSOuterDewar_Thickness, SSOuterDewar_OuterRadius, SSOuterDewar_TotHeight/2, 0.*deg, 360*deg);
G4LogicalVolume *SSInnerDewar_Logical = new G4LogicalVolume(SSInnerDewar, steel, "SSInnerDewar_Logical");
G4LogicalVolume *SSOuterDewar_Logical = new G4LogicalVolume(SSOuterDewar, steel, "SSOuterDewar_Logical");
new G4PVPlacement(0, G4ThreeVector(SSInnerDewar_xCenterPosition, SSInnerDewar_yCenterPosition, SSInnerDewar_zCenterPosition), SSInnerDewar_Logical, "SSInnerDewar Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(SSOuterDewar_xCenterPosition, SSOuterDewar_yCenterPosition, SSOuterDewar_zCenterPosition), SSOuterDewar_Logical, "SSOuterDewar Physical", fpWorldLogical, true, 1, true);
G4Box *HoldingBar = new G4Box("HoldingBar", DewarHoldingBar_Width/2, DewarHoldingBar_Long/2, DewarHoldingBar_Height/2);
G4LogicalVolume *HoldingBar_Logical = new G4LogicalVolume(HoldingBar, steel, "HoldingBar_Logical");
new G4PVPlacement(0, G4ThreeVector(HoldingBar_xPosition, HoldingBar_yPosition, HoldingBar_zPosition), HoldingBar_Logical, "SSInnerDewar Top HoldingBar Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(HoldingBar_xPosition, -HoldingBar_yPosition, HoldingBar_zPosition), HoldingBar_Logical, "SSInnerDewar Bottom HoldingBar Physical", fpWorldLogical, true, 1, true);
//SSInnerDewar_Logical->SetVisAttributes(G4Colour::Grey());
//SSOuterDewar_Logical->SetVisAttributes(G4Colour::Grey());
//HoldingBar_Logical->SetVisAttributes(G4Colour::Grey());
SSInnerDewar_Logical->SetVisAttributes(SS_Color);
SSOuterDewar_Logical->SetVisAttributes(SS_Color);
HoldingBar_Logical->SetVisAttributes(SS_Color);
//------------------------heat exchanger and attachments----------------------------------------
//---** heat exchanger geometry, back and right angle is set to position x=0, y=0 **---
//-- bar dimensions 1.25” X 0.75” X 15”
//-- plate dimensions 8.25” X 6” X 0.625”
//-- The bottom of the plate is 3.25” from the bottom of the bar
//-- Heat Exchanger 127W x 516H x 55D
G4Box *HeatExchanger_HoldingBar = new G4Box("HeatExchanger_HoldingBar", 1.25*25.4*mm/2, 0.75*25.4*mm/2, 15*25.4*mm/2);
G4Box *HeatExchanger_HoldingPlate = new G4Box("HeatExchanger_HoldingPlate", 6*25.4*mm/2, 0.625*25.4*mm/2,8.25*25.4*mm/2);
G4Box *HeatExchanger = new G4Box("HeatExchanger", 127*mm/2, 55*mm/2, 516*mm/2);
G4LogicalVolume *HeatExchanger_HoldingBar_Logical = new G4LogicalVolume(HeatExchanger_HoldingBar, steel, "HeatExchanger_HoldingBar_Logical");
G4LogicalVolume *HeatExchanger_HoldingPlate_Logical = new G4LogicalVolume(HeatExchanger_HoldingPlate, steel, "HeatExchanger_HoldingPlate_Logical");
G4LogicalVolume *HeatExchanger_Logical = new G4LogicalVolume(HeatExchanger, SS316L, "HeatExchanger_Logical");
new G4PVPlacement(0, G4ThreeVector(-127*mm/2-6*25.4*mm/2+1.25*25.4*mm/2, -0.625*25.4*mm-0.75*25.4*mm/2, SSOuterDewar_zCenterPosition+SSOuterDewar_TotHeight/2-15*25.4/2*mm), HeatExchanger_HoldingBar_Logical, "HeatExchanger HoldingBar Physical", fpWorldLogical, true, 0, true);
new G4PVPlacement(0, G4ThreeVector(-127*mm/2, -0.625*25.4*mm/2, SSOuterDewar_zCenterPosition+SSOuterDewar_TotHeight/2-15*25.4*mm-3.25*25.4*mm+8.25*25.4*mm/2), HeatExchanger_HoldingPlate_Logical, "HeatExchanger HoldingPlate Physical", fpWorldLogical, true, 0, true);
new G4PVPlacement(0, G4ThreeVector(-127*mm/2, 55*mm/2, SSOuterDewar_zCenterPosition+SSOuterDewar_TotHeight/2-15*25.4*mm-3.25*25.4*mm+8.25*25.4*mm/2), HeatExchanger_Logical, "HeatExchanger Physical", fpWorldLogical, true, 0, true);
//HeatExchanger_HoldingBar_Logical->SetVisAttributes(G4Colour::Grey());
//HeatExchanger_HoldingPlate_Logical->SetVisAttributes(G4Colour::Grey());
//HeatExchanger_Logical->SetVisAttributes(G4Colour::White());
HeatExchanger_HoldingBar_Logical->SetVisAttributes(SS_Color);
HeatExchanger_HoldingPlate_Logical->SetVisAttributes(SS_Color);
HeatExchanger_Logical->SetVisAttributes(SS_Color);
//---------------------Coldhead, PT60 from Cryomech-------------------------------------------
const G4double Coldehead_xCenterPosition = -SSInnerDewar_xCenterPosition + SSInnerDewar_OuterRadius+15*mm;
const G4double Coldehead_yCenterPosition = SSInnerDewar_yCenterPosition;
const G4double Coldehead_zCenterPosition = SSOuterDewar_zCenterPosition + SSOuterDewar_TotHeight/2 + SSOuterDewar_CF1650Flange_TotHeight;
const G4double Coldehead_ColumnHeight = 176.1*mm-7.7*mm-SSOuterDewar_CF1650Flange_TotHeight;
const G4double Coldehead_FlangeRadius = 124.5*mm/2;
G4Tubs *Coldhead_Flange = new G4Tubs("Coldhead_Flange", 0.*mm, Coldehead_FlangeRadius, 12.7*mm/2, 0.*deg, 360*deg);
G4Tubs *Coldhead_Column = new G4Tubs("Coldhead_Column", 0.*mm, 70.6*mm/4, Coldehead_ColumnHeight/2, 0.*deg, 360*deg);
G4Box *Coldehead_TopBox = new G4Box("Coldehead_TopBox", Coldehead_FlangeRadius*1.4142/2, Coldehead_FlangeRadius*1.4142/2, 205.6*mm/2);
G4LogicalVolume *Coldhead_Flange_Logical = new G4LogicalVolume(Coldhead_Flange, steel, "Coldhead_Flange_Logical");
G4LogicalVolume *Coldehead_TopBox_Logical = new G4LogicalVolume(Coldehead_TopBox, steel, "Coldehead_TopBox_Logical");
G4LogicalVolume *Coldhead_Column_Logical = new G4LogicalVolume(Coldhead_Column, copper, "Coldhead_Column_Logical");
new G4PVPlacement(0, G4ThreeVector(Coldehead_xCenterPosition, Coldehead_yCenterPosition, Coldehead_zCenterPosition+12.7*mm/2), Coldhead_Flange_Logical, "Coldhead SSFlange Physical", fpWorldLogical, true, 0, true);
new G4PVPlacement(0, G4ThreeVector(Coldehead_xCenterPosition, Coldehead_yCenterPosition, Coldehead_zCenterPosition+12.7*mm+205.6*mm/2), Coldehead_TopBox_Logical, "Coldehead TopBox Physical", fpWorldLogical, true, 0, true);
new G4PVPlacement(0, G4ThreeVector(Coldehead_xCenterPosition - 70.6*mm/4, Coldehead_yCenterPosition, SSOuterDewar_zCenterPosition + SSOuterDewar_TotHeight/2 - Coldehead_ColumnHeight/2), Coldhead_Column_Logical, "Coldhead Column Physical 1", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(Coldehead_xCenterPosition + 70.6*mm/4, Coldehead_yCenterPosition, SSOuterDewar_zCenterPosition + SSOuterDewar_TotHeight/2 - Coldehead_ColumnHeight/2), Coldhead_Column_Logical, "Coldhead Column Physical 2", fpWorldLogical, true, 1, true);
//Coldhead_Flange_Logical->SetVisAttributes(G4Colour::Grey());
//Coldhead_Column_Logical->SetVisAttributes(G4Colour::Grey());
//Coldehead_TopBox_Logical->SetVisAttributes(G4Colour::White());
Coldhead_Flange_Logical->SetVisAttributes(SS_Color);
Coldhead_Column_Logical->SetVisAttributes(SS_Color);
Coldehead_TopBox_Logical->SetVisAttributes(SS_Color);
const G4int Coldhead_zPlaneNbr = 7;
const G4double Coldehead_zPlane[Coldhead_zPlaneNbr] = {0.*mm, -0.31*25.4*mm, -0.31*25.4*mm, (-0.31-0.41)*25.4*mm, (-0.31-0.41)*25.4*mm, (-0.31-0.41-0.65)*25.4*mm, (-0.31-1.76)*25.4*mm};
const G4double Coldehead_rInner[Coldhead_zPlaneNbr] = {0.*mm, 0.*mm, 0.*mm, 0.*mm, 0.*mm, 0.*mm, 0.*mm};
const G4double Coldehead_rOuter[Coldhead_zPlaneNbr] = {2.78/2*25.4*mm, 2.78/2*25.4*mm, 4.348/2*25.4*mm, 4.348/2*25.4*mm, 4/2*25.4*mm, 4/2*25.4*mm, 0.*mm};
G4Polycone *Coldhead = new G4Polycone("Coldhead", 0.*deg, 360.0*deg, Coldhead_zPlaneNbr, Coldehead_zPlane, Coldehead_rInner, Coldehead_rOuter);
G4LogicalVolume* Coldhead_Logical = new G4LogicalVolume(Coldhead , copper, "Coldhead_Logical");
new G4PVPlacement(0, G4ThreeVector(Coldehead_xCenterPosition, Coldehead_yCenterPosition, SSOuterDewar_zCenterPosition + SSOuterDewar_TotHeight/2 - Coldehead_ColumnHeight), Coldhead_Logical, "Coldhead Physical", fpWorldLogical, true, 1, true);
const G4int Coldhead_Cup_zPlaneNbr = 4;
const G4double Coldhead_Cup_zPlane[Coldhead_Cup_zPlaneNbr] = {0.*mm, -4.7*25.4*mm, -4.7*25.4*mm, (-4.7-0.08)*25.4*mm};
const G4double Coldhead_Cup_rInner[Coldhead_Cup_zPlaneNbr] = {2*25.4*mm, 2*25.4*mm, 0.*mm, 0.*mm};
const G4double Coldhead_Cup_rOuter[Coldhead_Cup_zPlaneNbr] = {(2+0.08)*25.4*mm, (2+0.08)*25.4*mm, (2+0.08)*25.4*mm, (2+0.08)*25.4*mm};
G4Polycone *Coldhead_Cup = new G4Polycone("Coldhead_Cup", 0.*deg, 360.0*deg, Coldhead_Cup_zPlaneNbr, Coldhead_Cup_zPlane, Coldhead_Cup_rInner, Coldhead_Cup_rOuter);
G4LogicalVolume* Coldhead_Cup_Logical = new G4LogicalVolume(Coldhead_Cup , steel, "Coldhead_Cup_Logical");
new G4PVPlacement(0, G4ThreeVector(Coldehead_xCenterPosition, Coldehead_yCenterPosition, SSOuterDewar_zCenterPosition + SSOuterDewar_TotHeight/2 - Coldehead_ColumnHeight-0.72*25.4*mm), Coldhead_Cup_Logical, "Coldhead Cup Physical", fpWorldLogical, true, 1, true);
Coldhead_Cup_Logical->SetVisAttributes(G4Colour::Yellow());
Coldhead_Logical->SetVisAttributes(G4Colour::Yellow());
//-----------------------------------------------------------------------------------------
//--- Oct. 11th
//--- SCENE prototype TPC, the orign is center/middle of Inner SS Dewar. -----
//--- TPC_zAxis_Offset adjusts the location of TPC with respect to the orign -----
//--- TPC zAixis Center is the interface of Liquid/Gas ---
//--- New G4 geometry function is use.
//---- From upper surface of the bottom quartz window to the bottom flange is 1 foot. ---
const G4double TPC_zAxis_Offset = 0.*25.4*mm; // equals to SSInnerDewar_TotHeight/2+12*25.4*mm+3.*25.4*mm;
const G4double LAr_Volume_Height = SSInnerDewar_TotHeight/2-TPC_zAxis_Offset;
const G4double LAr_Volume_Radius = SSInnerDewar_OuterRadius-SSInnerDewar_Thickness;
const G4double GAr_Volume_Height = SSInnerDewar_TotHeight/2+TPC_zAxis_Offset;
const G4double GAr_Volume_Radius = SSInnerDewar_OuterRadius-SSInnerDewar_Thickness;
//const G4double LArSubtraction_Volume_Height = 3.*25.4*mm;
//const G4double LArSubtraction_Volume_Diameter = 2.7*25.4*mm;
//--------------TPC Dimensions--------------
const G4double ActiveGAr_Volume_Height = 0.25*25.4*mm;
const G4double ActiveGAr_Volume_Diameter = 2.7*25.4*mm;
const G4double ActiveLAr_Volume_Height = 3.*25.4*mm;
const G4double ActiveLAr_Volume_Diameter = 2.7*25.4*mm;
const G4double QuartzWindow_Volume_Height = 0.6*25.4*mm;
const G4double QuartzWindow_Volume_Diameter = 3.*25.4*mm;
const G4double PTFERing_Volume_Height = 2*25.4*mm;
const G4double PTFERing_Volume_InnerDiameter = 3*25.4*mm;
const G4double PTFERing_Volume_OuterDiameter = 3.8*25.4*mm;
const G4double PTFEColumn_Volume_xHalfLength = 0.5/2*25.4*mm;
const G4double PTFEColumn_Volume_yHalfLength = 0.5/2*25.4*mm;
const G4double PTFEColumn_LArVolume_zHalfLength = ActiveLAr_Volume_Height/2;
const G4double PTFEColumn_GArVolume_zHalfLength = ActiveGAr_Volume_Height/2;
//---------------3" PMT Solid Part ------------
const G4double TopPMT_zOffset = -TPC_zAxis_Offset+ActiveGAr_Volume_Height+QuartzWindow_Volume_Height;
const G4double BtmPMT_zOffset = -TPC_zAxis_Offset-ActiveLAr_Volume_Height-QuartzWindow_Volume_Height;
const G4double PMT_TotLength = 123.063*mm;
const G4int PMTzPlaneNbr = 8;
const G4double PMTShellThickness = 0.5*mm;
//const G4double PMTzPlane[PMTzPlaneNbr] = {0.*mm+PMT_zOffset, -17.4115*mm+PMT_zOffset, -35.041*mm+PMT_zOffset, -39.9343*mm+PMT_zOffset, -116.*mm+PMT_zOffset, -116.078*mm+PMT_zOffset, -116.713*mm+PMT_zOffset, -PMT_TotLength+PMT_zOffset};
const G4double PMTzPlane[PMTzPlaneNbr] = {0.*mm, -17.4115*mm, -35.041*mm, -39.9343*mm, -116.*mm, -116.078*mm, -116.713*mm, -PMT_TotLength};
const G4double PMTrInner[PMTzPlaneNbr] = {36.576*mm, 36.576*mm, 28.0201*mm, 25.146*mm, 25.146*mm, 0.*mm, 0.*mm, 25.126*mm};
const G4double PMTrOuter[PMTzPlaneNbr] = {36.576*mm+PMTShellThickness, 36.576*mm+PMTShellThickness, 28.0201*mm+PMTShellThickness, 25.146*mm+PMTShellThickness, 25.146*mm+PMTShellThickness, 25.146*mm+PMTShellThickness, 25.146*mm+PMTShellThickness, 25.146*mm+PMTShellThickness};
const G4double PMT_QuartzWindow_Radius = 35.576*mm;
const G4double PMT_QuartzWindow_TotLength = 3.4*mm;
//-----------------------------------------------
const G4double LArSubtraction_Volume_Height = PMT_TotLength+ActiveLAr_Volume_Height+QuartzWindow_Volume_Height;
const G4double GArSubtraction_Volume_Height = PMT_TotLength+ActiveGAr_Volume_Height+QuartzWindow_Volume_Height;
const G4double LArSubtraction_Volume_Diameter = QuartzWindow_Volume_Diameter;
const G4double GArSubtraction_Volume_Diameter = QuartzWindow_Volume_Diameter;
//--------------------------------------------------------------------------------------------
//---------------Dead LAr and GAr ------------
G4Tubs *LAr_Volume = new G4Tubs("LAr_Volume", 0.*mm, LAr_Volume_Radius, LAr_Volume_Height/2, 0.*deg, 360*deg);
G4Tubs *GAr_Volume = new G4Tubs("GAr_Volume", 0.*mm, GAr_Volume_Radius, GAr_Volume_Height/2, 0.*deg, 360*deg);
G4Tubs *LArSubtraction_Volume = new G4Tubs("LArSubtraction_Volume", 0.*mm, LArSubtraction_Volume_Diameter/2, LArSubtraction_Volume_Height/2, 0.*deg, 360*deg);
G4Tubs *GArSubtraction_Volume = new G4Tubs("GArSubtraction_Volume", 0.*mm, GArSubtraction_Volume_Diameter/2, GArSubtraction_Volume_Height/2, 0.*deg, 360*deg);
//---------LAr PTFE Part ------------
G4Tubs *PTFERing_Volume = new G4Tubs("PTFERing_Volume", PTFERing_Volume_InnerDiameter/2, PTFERing_Volume_OuterDiameter/2, PTFERing_Volume_Height/2, 0.*deg, 360*deg);
G4Box *PTFEColumn_BtmVolume = new G4Box("PTFEColumn_BtmVolume", PTFEColumn_Volume_xHalfLength, PTFEColumn_Volume_yHalfLength, PTFEColumn_LArVolume_zHalfLength);
G4RotationMatrix Rotat_PTFEColumn;
G4ThreeVector Vector_PTFEColumn;
Vector_PTFEColumn.setX(PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength);
Vector_PTFEColumn.setY(0.*mm);
Vector_PTFEColumn.setZ(PTFEColumn_LArVolume_zHalfLength+PTFERing_Volume_Height/2);
G4VSolid* PTFE_Leg1_Volume = new G4UnionSolid("PTFE_Leg1_Volume", PTFERing_Volume, PTFEColumn_BtmVolume, G4Transform3D(Rotat_PTFEColumn, Vector_PTFEColumn));
Rotat_PTFEColumn.rotateZ(120.0*deg);
Vector_PTFEColumn.setX((PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength)*std::cos(120./180.*3.1415926));
Vector_PTFEColumn.setY((PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength)*std::sin(120./180.*3.1415926));
Vector_PTFEColumn.setZ(PTFEColumn_LArVolume_zHalfLength+PTFERing_Volume_Height/2);
G4VSolid* PTFE_Leg2_Volume = new G4UnionSolid("PTFE_Leg2_Volume", PTFE_Leg1_Volume, PTFEColumn_BtmVolume, G4Transform3D(Rotat_PTFEColumn, Vector_PTFEColumn));
Rotat_PTFEColumn.rotateZ(120.0*deg);
Vector_PTFEColumn.setX((PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength)*std::cos(240./180.*3.1415926));
Vector_PTFEColumn.setY((PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength)*std::sin(240./180.*3.1415926));
Vector_PTFEColumn.setZ(PTFEColumn_LArVolume_zHalfLength+PTFERing_Volume_Height/2);
G4VSolid* PTFE_BtmVolume = new G4UnionSolid("PTFE_BtmVolume", PTFE_Leg2_Volume, PTFEColumn_BtmVolume, G4Transform3D(Rotat_PTFEColumn, Vector_PTFEColumn));
//--------------GAr PTFE part-------------------
G4Box *PTFEColumn_TopVolume = new G4Box("PTFEColumn_TopVolume", PTFEColumn_Volume_xHalfLength, PTFEColumn_Volume_yHalfLength, PTFEColumn_GArVolume_zHalfLength);
Rotat_PTFEColumn.rotateZ(120.0*deg);
Vector_PTFEColumn.setX(PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength);
Vector_PTFEColumn.setY(0.*mm);
Vector_PTFEColumn.setZ(-PTFEColumn_GArVolume_zHalfLength-PTFERing_Volume_Height/2);
G4VSolid* PTFE_Leg1_TopVolume = new G4UnionSolid("PTFE_Leg1_TopVolume", PTFERing_Volume, PTFEColumn_TopVolume, G4Transform3D(Rotat_PTFEColumn, Vector_PTFEColumn));
Rotat_PTFEColumn.rotateZ(120.0*deg);
Vector_PTFEColumn.setX((PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength)*std::cos(120./180.*3.1415926));
Vector_PTFEColumn.setY((PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength)*std::sin(120./180.*3.1415926));
Vector_PTFEColumn.setZ(-PTFEColumn_GArVolume_zHalfLength-PTFERing_Volume_Height/2);
G4VSolid* PTFE_Leg2_TopVolume = new G4UnionSolid("PTFE_Leg2_TopVolume", PTFE_Leg1_TopVolume, PTFEColumn_TopVolume, G4Transform3D(Rotat_PTFEColumn, Vector_PTFEColumn));
Rotat_PTFEColumn.rotateZ(120.0*deg);
Vector_PTFEColumn.setX((PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength)*std::cos(240./180.*3.1415926));
Vector_PTFEColumn.setY((PTFERing_Volume_OuterDiameter/2-PTFEColumn_Volume_yHalfLength)*std::sin(240./180.*3.1415926));
Vector_PTFEColumn.setZ(-PTFEColumn_GArVolume_zHalfLength-PTFERing_Volume_Height/2);
G4VSolid* PTFE_TopVolume = new G4UnionSolid("PTFE_Volume", PTFE_Leg2_TopVolume, PTFEColumn_TopVolume, G4Transform3D(Rotat_PTFEColumn, Vector_PTFEColumn));
//---------------------------------------------
G4VSolid* LArSubtraction_Part= new G4UnionSolid("LArSubtraction_Part", LArSubtraction_Volume, PTFE_BtmVolume, 0, G4ThreeVector(0., 0., LArSubtraction_Volume_Height/2-PTFERing_Volume_Height/2-PTFEColumn_LArVolume_zHalfLength*2));
G4VSolid* GArSubtraction_Part= new G4UnionSolid("GArSubtraction_Part", GArSubtraction_Volume, PTFE_TopVolume, 0, G4ThreeVector(0., 0., -GArSubtraction_Volume_Height/2+PTFERing_Volume_Height/2+PTFEColumn_GArVolume_zHalfLength*2));
//G4LogicalVolume *Test_Logical = new G4LogicalVolume(LArSubtraction_Part, quartz, "Test_Logical");
//new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), Test_Logical, "Test Volume Physical", fpWorldLogical, true, 1, true);
G4SubtractionSolid* NewLAr_Volume = new G4SubtractionSolid("NewLAr_Volume", LAr_Volume, LArSubtraction_Part, 0, G4ThreeVector(0.,0.,(LAr_Volume_Height-LArSubtraction_Volume_Height)/2));
G4SubtractionSolid* NewGAr_Volume = new G4SubtractionSolid("NewGAr_Volume", GAr_Volume, GArSubtraction_Part, 0, G4ThreeVector(0.,0.,(-GAr_Volume_Height+GArSubtraction_Volume_Height)/2));
G4LogicalVolume *LAr_Volume_Logical = new G4LogicalVolume(NewLAr_Volume, LAr, "LAr_Volume_Logical");
G4LogicalVolume *GAr_Volume_Logical = new G4LogicalVolume(NewGAr_Volume, GAr, "GAr_Volume_Logical");
LAr_Volume_Logical->SetVisAttributes(G4VisAttributes::Invisible);
GAr_Volume_Logical->SetVisAttributes(G4VisAttributes::Invisible);
new G4PVPlacement(0, G4ThreeVector(0., 0., -LAr_Volume_Height/2-TPC_zAxis_Offset), LAr_Volume_Logical, "LAr Volume Physical", fpWorldLogical, false, 1, true);
new G4PVPlacement(0, G4ThreeVector(0., 0., GAr_Volume_Height/2-TPC_zAxis_Offset), GAr_Volume_Logical, "GAr Volume Physical", fpWorldLogical, false, 1, true);
G4LogicalVolume *PTFE_BtmVolume_Logical = new G4LogicalVolume(PTFE_BtmVolume, PTFE, "PTFE_BtmVolume_Logical");
G4LogicalVolume *PTFE_TopVolume_Logical = new G4LogicalVolume(PTFE_TopVolume, PTFE, "GAr_Volume_Logical");
//PTFE_BtmVolume_Logical->SetVisAttributes(G4Colour::Grey());
//PTFE_TopVolume_Logical->SetVisAttributes(G4Colour::Grey());
PTFE_BtmVolume_Logical->SetVisAttributes(G4Colour::Magenta());
PTFE_TopVolume_Logical->SetVisAttributes(G4Colour::Magenta());
new G4PVPlacement(0, G4ThreeVector(0., 0., -PTFERing_Volume_Height/2-TPC_zAxis_Offset-PTFEColumn_LArVolume_zHalfLength*2), PTFE_BtmVolume_Logical, "Bottom PTFE Volume Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(0., 0., PTFERing_Volume_Height/2+PTFEColumn_GArVolume_zHalfLength*2-TPC_zAxis_Offset), PTFE_TopVolume_Logical, "GAr Volume Physical", fpWorldLogical, true, 1, true);
//---------------Active LAr and GAr ------------
G4Tubs *ActiveLAr_Volume = new G4Tubs("ActiveLAr_Volume", 0.*mm, ActiveLAr_Volume_Diameter/2, ActiveLAr_Volume_Height/2, 0.*deg, 360*deg);
G4Tubs *ActiveGAr_Volume = new G4Tubs("ActiveGAr_Volume", 0.*mm, ActiveGAr_Volume_Diameter/2, ActiveGAr_Volume_Height/2, 0.*deg, 360*deg);
G4LogicalVolume *ActiveLAr_Volume_Logical = new G4LogicalVolume(ActiveLAr_Volume, LAr, "ActiveLAr_Volume_Logical");
G4LogicalVolume *ActiveGAr_Volume_Logical = new G4LogicalVolume(ActiveGAr_Volume, GAr, "ActiveGAr_Volume_Logical");
ActiveGAr_Volume_Logical->SetVisAttributes(G4Colour::Green());
ActiveLAr_Volume_Logical->SetVisAttributes(G4Colour::Blue());
new G4PVPlacement(0, G4ThreeVector(0., 0., -ActiveLAr_Volume_Height/2-TPC_zAxis_Offset), ActiveLAr_Volume_Logical, "ActiveLAr Volume Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(0., 0., ActiveGAr_Volume_Height/2-TPC_zAxis_Offset), ActiveGAr_Volume_Logical, "ActiveGAr Volume Physical", fpWorldLogical, true, 1, true);
//---------------Quartz Window ------------------
G4Tubs *QuartzWindow_Volume = new G4Tubs("QuartzWindow_Volume", 0.*mm, QuartzWindow_Volume_Diameter/2, QuartzWindow_Volume_Height/2, 0.*deg, 360*deg);
G4LogicalVolume *QuartzWindow_Volume_Logical = new G4LogicalVolume(QuartzWindow_Volume, quartz, "QuartzWindow_Volume_Logical");
QuartzWindow_Volume_Logical->SetVisAttributes(G4Colour::Red());
G4RotationMatrix Rotat_QuartzWindow;
G4ThreeVector Vector_QuartzWindow;
Rotat_QuartzWindow.rotateY(180.0*deg);
Vector_QuartzWindow.setX(0.*mm);
Vector_QuartzWindow.setY(0.*mm);
Vector_QuartzWindow.setZ(QuartzWindow_Volume_Height/2-TPC_zAxis_Offset+ActiveGAr_Volume_Height);
new G4PVPlacement(G4Transform3D(Rotat_QuartzWindow, Vector_QuartzWindow), QuartzWindow_Volume_Logical, "Top Quartz Window Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(0,0,-ActiveLAr_Volume_Height-TPC_zAxis_Offset-QuartzWindow_Volume_Height/2), QuartzWindow_Volume_Logical, "Bottom Quartz Window Physical", fpWorldLogical, true, 1, true);
//-----------------3" PMT Solid Part ---------------
G4Polycone *PMT_Shell = new G4Polycone("PMT_Shell", 0.*deg, 360.0*deg, PMTzPlaneNbr, PMTzPlane, PMTrInner, PMTrOuter);
G4LogicalVolume* PMT_Shell_Logical = new G4LogicalVolume(PMT_Shell, Kovar, "PMT_Shell_Logical");
G4RotationMatrix Rotat_TopPMT;
G4ThreeVector Vector_TopPMT;
Rotat_TopPMT.rotateY(180.0*deg);
Vector_TopPMT.setX(0.*mm); Vector_TopPMT.setY(0.*mm); Vector_TopPMT.setZ(TopPMT_zOffset);
new G4PVPlacement(G4Transform3D(Rotat_TopPMT, Vector_TopPMT), PMT_Shell_Logical, "Top PMT Shell Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(0,0,BtmPMT_zOffset), PMT_Shell_Logical, "Bottom PMT Shell Physical", fpWorldLogical, true, 1, true);
G4Tubs *PMT_QuartzWindow = new G4Tubs("PMT_QuartzWindow", 0.*mm, PMT_QuartzWindow_Radius, PMT_QuartzWindow_TotLength/2, 0.*deg, 360*deg);
G4LogicalVolume *PMT_QuartzWindow_Logical = new G4LogicalVolume(PMT_QuartzWindow, quartz, "PMT_QuartzWindow_Logical");
PMT_QuartzWindow_Logical->SetVisAttributes(G4Colour::Red());
//PMT_Shell_Logical->SetVisAttributes(G4Colour::Yellow());
PMT_Shell_Logical->SetVisAttributes(G4Colour::Cyan());
new G4PVPlacement(0, G4ThreeVector(0,0, TopPMT_zOffset+PMT_QuartzWindow_TotLength/2), PMT_QuartzWindow_Logical, "Top PMT QuartzWindow Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(0,0, BtmPMT_zOffset-PMT_QuartzWindow_TotLength/2), PMT_QuartzWindow_Logical, "Bottom PMT QuartzWindow Physical", fpWorldLogical, true, 1, true);
//-----------------------------------------------
/*
//----------------- Test Oject ------------------
G4Tubs* Test_tube = new G4Tubs("Test_tube", 0.*cm, 20.*cm, 0.01*cm, 0.*deg, 360.*deg);
G4LogicalVolume* Test_tube_Logical = new G4LogicalVolume(Test_tube, EJ301, "Test_tube_Logical");
new G4PVPlacement(0, G4ThreeVector(0, 0, 0), Test_tube_Logical, "Test Physical", fpWorldLogical, true, 1, true);
Test_tube_Logical->SetVisAttributes(G4Colour::Red());
//-----------------------------------------------
*/
//--------------------------------------------------------------------------------------------
//--- for 2"DIA x 2" Chamber of Scintillator, neutron detector ---
const G4double EJ_Radius = 2.5*2.54*cm;
const G4double EJ_halfHeight = 2.5*2.54*cm;
const G4double TPC_Center_zAxis_Offset = -1.5*2.54*cm; //----- TPC center is the LAr center -------
/*
const double TopEJ_Angle = 24.72/180*TMath::Pi();
double LiF_PositionX = -64.77;
double LiF_PositionY = 0.;
double LiF_PositionZ = 31.36;
double TopEJ301Center_PositionX = 71.12*TMath::Cos(TopEJ_Angle);
double TopEJ301Center_PositionY = 0.;
double TopEJ301Center_PositionZ = 71.12*TMath::Sin(TopEJ_Angle);
double SideEJ301Center_PositionX = 40.663;
double SideEJ301Center_PositionY = 54.9253; //--- (+/-) ---
double SideEJ301Center_PositionZ = -19.6923;
*/
G4Tubs* EJ_tube = new G4Tubs("EJ_tube", 0.*cm, EJ_Radius, EJ_halfHeight, 0.*deg, 360.*deg);
G4LogicalVolume* EJ_tube_Logical = new G4LogicalVolume(EJ_tube, EJ301, "EJ_tube_Logical");
EJ_tube_Logical->SetVisAttributes(G4Colour::Red());
G4RotationMatrix R_EJ1, R_EJ2, R_EJ3;
G4ThreeVector T_EJ1, T_EJ2, T_EJ3;
const double PiValue = 3.1415926;
//--- old values ----
//const double TopEJ_xyPlane_Angle = 24.72;
//const double SideEJ_Theta_Angle = 16.0727;
//const double SideEJ_Alpha_Angle = 53.486;
const double Dip_Angle = 25.44; //--- unit: deg ---
const double Scatter_Angle = 49.9; //--- unit: deg ---
const double TopEJ_xyPlane_Angle = Scatter_Angle - Dip_Angle;
const double SideEJ_Theta_Angle = 16.0642;
const double SideEJ_Alpha_Angle = 52.7497;
R_EJ1.rotateX((90-TopEJ_xyPlane_Angle)*deg);
R_EJ1.rotateZ(89.9*deg);
// R_EJ1.rotateZ(0.09*deg);
//R_EJ1->rotateY((90.+TopEJ_xyPlane_Angle)*deg);
R_EJ2.rotateX((SideEJ_Theta_Angle-90)*deg);
R_EJ3.rotateX((90-SideEJ_Theta_Angle)*deg);
R_EJ2.rotateZ(( SideEJ_Alpha_Angle)*deg);
R_EJ3.rotateZ((-90+SideEJ_Alpha_Angle)*deg);
const G4double ProtonBeam_Line_zAxis_Pos = (31.4-1.5*2.54)*cm;
const G4double zAxis_TPC_Offset = -1.5*2.54*cm;
const G4double TPC_EJ_Distance = 28*2.54*cm; //----(to the front end of EJs)----
const G4double EJ1_xAxis_Pos = (TPC_EJ_Distance + EJ_halfHeight)*std::cos(TopEJ_xyPlane_Angle/180.*PiValue);
const G4double EJ1_zAxis_Pos = (TPC_EJ_Distance + EJ_halfHeight)*std::sin(TopEJ_xyPlane_Angle/180.*PiValue) + TPC_Center_zAxis_Offset;
const G4double EJ2_xAxis_Pos = (TPC_EJ_Distance + EJ_halfHeight)*std::cos(SideEJ_Theta_Angle/180.*PiValue)*std::cos(SideEJ_Alpha_Angle/180.*PiValue);
const G4double EJ2_yAxis_Pos = -(TPC_EJ_Distance + EJ_halfHeight)*std::cos(SideEJ_Theta_Angle/180.*PiValue)*std::sin(SideEJ_Alpha_Angle/180.*PiValue);
const G4double EJ2_zAxis_Pos = -(TPC_EJ_Distance + EJ_halfHeight)*std::sin(SideEJ_Theta_Angle/180.*PiValue) + TPC_Center_zAxis_Offset;
/*
//********* Test Parameters ***********
const G4double EJ2_xAxis_Pos = (TPC_EJ_Distance )*std::cos(SideEJ_Theta_Angle/180.*PiValue)*std::cos(SideEJ_Alpha_Angle/180.*PiValue);
const G4double EJ2_yAxis_Pos = -(TPC_EJ_Distance )*std::cos(SideEJ_Theta_Angle/180.*PiValue)*std::sin(SideEJ_Alpha_Angle/180.*PiValue);
const G4double EJ2_zAxis_Pos = -(TPC_EJ_Distance )*std::sin(SideEJ_Theta_Angle/180.*PiValue) + TPC_Center_zAxis_Offset;
*/
const G4double EJ3_xAxis_Pos = (TPC_EJ_Distance + EJ_halfHeight)*std::cos(SideEJ_Theta_Angle/180.*PiValue)*std::cos(SideEJ_Alpha_Angle/180.*PiValue);
const G4double EJ3_yAxis_Pos = (TPC_EJ_Distance + EJ_halfHeight)*std::cos(SideEJ_Theta_Angle/180.*PiValue)*std::sin(SideEJ_Alpha_Angle/180.*PiValue);
const G4double EJ3_zAxis_Pos = -(TPC_EJ_Distance + EJ_halfHeight)*std::sin(SideEJ_Theta_Angle/180.*PiValue) + TPC_Center_zAxis_Offset;
//std::cout<<"The EJ2 Position: "<<EJ2_xAxis_Pos/cm<<", "<<EJ2_yAxis_Pos/cm<<", "<<(EJ2_zAxis_Pos-TPC_Center_zAxis_Offset)/cm<<std::endl;
T_EJ1.setX(EJ1_xAxis_Pos);
T_EJ1.setZ(EJ1_zAxis_Pos);
//T_EJ1->setX(EJ1_xAxis_Pos);
//T_EJ1->setZ(EJ1_zAxis_Pos);
T_EJ2.setX(EJ2_xAxis_Pos);
T_EJ2.setY(EJ2_yAxis_Pos);
T_EJ2.setZ(EJ2_zAxis_Pos);
T_EJ3.setY(EJ3_yAxis_Pos);
T_EJ3.setX(EJ3_xAxis_Pos);
T_EJ3.setZ(EJ3_zAxis_Pos);
//new G4PVPlacement( R_EJ1, G4ThreeVector(EJ1_xAxis_Pos, 0, EJ1_zAxis_Pos), EJ_tube_Logical, "EJ301_1", fpWorldLogical, true, 0);
new G4PVPlacement(G4Transform3D(R_EJ1, T_EJ1), EJ_tube_Logical, "EJ301_1", fpWorldLogical, true, 1, true);
new G4PVPlacement(G4Transform3D(R_EJ2, T_EJ2), EJ_tube_Logical, "EJ301_2", fpWorldLogical, true, 1, true);
new G4PVPlacement(G4Transform3D(R_EJ3, T_EJ3), EJ_tube_Logical, "EJ301_3", fpWorldLogical, true, 1, true);
//----------------------------------------------------------------------------------------------------------------------
//--------------------------- SCENE PE & Paraffin Shielding Dimensions -------------------------------------
const G4double TPC_Center_Ground_Distance = 142.91*cm;
const G4double zAxis_TPC_Center_BeamLine_Distance = 31.4*cm;
const double EJ2_Shielding_Angle = 20;
//----- For EJ#1 & EJ#2, PE Shielding Dimension Dia. 8.75" x 8.75" --------
const G4double PE_Polythene_Shielding_Radius = 8.75*2.54/2*cm;
const G4double PE_Polythene_Shielding_Half_Length = 8.75*2.54/2*cm;
const G4double EJ1_Shielding_Btm_Ground_Distance = 166*cm;
const G4double EJ2_Shielding_Btm_Ground_Distance = 141*cm;
const G4double EJ1_Polythene_Shielding_xAxisPos = -SSOuterDewar_OuterRadius-PE_Polythene_Shielding_Radius;
const G4double EJ1_Polythene_Shielding_zAxisPos = EJ1_Shielding_Btm_Ground_Distance-TPC_Center_Ground_Distance+1.5*2.54*cm+PE_Polythene_Shielding_Half_Length;
const G4double EJ2_Polythene_Shielding_xAxisPos = -(PE_Polythene_Shielding_Radius+SSOuterDewar_OuterRadius)*std::sin(EJ2_Shielding_Angle/180.*PiValue);
const G4double EJ2_Polythene_Shielding_yAxisPos = -(PE_Polythene_Shielding_Radius+SSOuterDewar_OuterRadius)*std::cos(EJ2_Shielding_Angle/180.*PiValue);
const G4double EJ2_Polythene_Shielding_zAxisPos = EJ2_Shielding_Btm_Ground_Distance-TPC_Center_Ground_Distance+1.5*2.54*cm+PE_Polythene_Shielding_Half_Length;
G4Tubs* PE_Shielding_tube = new G4Tubs("PE_Shielding_tube", 0.*cm, PE_Polythene_Shielding_Radius, PE_Polythene_Shielding_Half_Length, 0.*deg, 360.*deg);
G4LogicalVolume* PE_Shielding_Logical = new G4LogicalVolume(PE_Shielding_tube, polyethylene, "PE_Shielding_Logical");
new G4PVPlacement(0, G4ThreeVector(EJ1_Polythene_Shielding_xAxisPos, 0, EJ1_Polythene_Shielding_zAxisPos), PE_Shielding_Logical, "EJ1_Shielding", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(EJ2_Polythene_Shielding_xAxisPos, EJ2_Polythene_Shielding_yAxisPos, EJ2_Polythene_Shielding_zAxisPos), PE_Shielding_Logical, "EJ2_Shielding", fpWorldLogical, false, 1, true);
//---------- For EJ#3 Paraffin Shielding 7.5" x 8.25" x 5.25" -------------
const G4double EJ3_Paraffin_Shielding_yAxis_Length = 7.5*2.54*cm;
const G4double EJ3_Paraffin_Shielding_zAxis_Length = 8.25*2.54*cm;
const G4double EJ3_Paraffin_Shielding_xAxis_Length = 5.25*2.54*cm;
const G4double EJ3_Paraffin_Shielding_yAxisPos = SSOuterDewar_OuterRadius + 11*2.54*cm - EJ3_Paraffin_Shielding_yAxis_Length/2;
const G4double EJ3_Paraffin_Shielding_xAxisPos = 1*2.54*cm + EJ3_Paraffin_Shielding_xAxis_Length/2;
const G4double EJ3_Paraffin_Shielding_zAxisPos = ProtonBeam_Line_zAxis_Pos - 18.5*2.54*cm + EJ3_Paraffin_Shielding_zAxis_Length;
G4Box *EJ3_Shielding_Box = new G4Box("EJ3_Shielding_Box", EJ3_Paraffin_Shielding_xAxis_Length/2, EJ3_Paraffin_Shielding_yAxis_Length/2, EJ3_Paraffin_Shielding_zAxis_Length/2);
G4LogicalVolume* EJ3_Shielding_Logical = new G4LogicalVolume(EJ3_Shielding_Box, paraffin, "EJ3_Shielding_Logical");
new G4PVPlacement(0, G4ThreeVector(EJ3_Paraffin_Shielding_xAxisPos, EJ3_Paraffin_Shielding_yAxisPos, EJ3_Paraffin_Shielding_zAxisPos), EJ3_Shielding_Logical, "EJ3_Shielding", fpWorldLogical, false, 1, true);
PE_Shielding_Logical->SetVisAttributes(G4Colour::Grey());
EJ3_Shielding_Logical->SetVisAttributes(G4Colour::Grey());
//--------------------------------------------------------------------------------------------------------------
//----------------------Aluminum Frame at the Bottom-----------------------------------------
const G4double Al_Frame_Btm_Ground_Distance = 6*2.54*cm;
const G4double Al_Frame_SideLength = 3.5*2.54*cm;
const G4double Al_Frame_xAxis_Length = 32*2.54*cm;
const G4double Al_Frame_yAxis_Length = 31*2.54*cm;
const G4double Al_Frame_LongBeam_yAxis_Length = 60*2.54*cm;
const G4double Al_Frame_xPosition = (Al_Frame_xAxis_Length+Al_Frame_SideLength)/2;
const G4double Al_Frame_zPosition = -TPC_Center_Ground_Distance-1.5*2.54*cm+Al_Frame_Btm_Ground_Distance+Al_Frame_SideLength/2;
G4Box *Al_Frame_Inner_Hollow = new G4Box("Al_Frame_Inner_Hollow", (Al_Frame_xAxis_Length-2*Al_Frame_SideLength)/2, (Al_Frame_yAxis_Length-2*Al_Frame_SideLength)/2, Al_Frame_SideLength);
G4Box *Al_Frame_Full_Box = new G4Box("Al_Frame_Full_Box", Al_Frame_xAxis_Length/2, Al_Frame_yAxis_Length/2, Al_Frame_SideLength/2);
G4SubtractionSolid* Al_Frame_Square = new G4SubtractionSolid("Al_Frame_Square", Al_Frame_Full_Box, Al_Frame_Inner_Hollow, 0, G4ThreeVector(0.,0.,0));
G4Box *Al_Frame_LongBeam = new G4Box("Al_Frame_LongBeam", Al_Frame_SideLength/2, Al_Frame_LongBeam_yAxis_Length/2, Al_Frame_SideLength/2);
G4LogicalVolume *Al_Frame_Square_Logic = new G4LogicalVolume(Al_Frame_Square, Al, "Al_Frame_Square_Logic");
G4LogicalVolume *Al_Frame_LongBeam_Logic = new G4LogicalVolume(Al_Frame_LongBeam, Al, "Al_Frame_LongBeam_Logic");
Al_Frame_Square_Logic->SetVisAttributes(Al_Color);
Al_Frame_LongBeam_Logic->SetVisAttributes(Al_Color);
new G4PVPlacement(0, G4ThreeVector(0., 0., -TPC_Center_Ground_Distance-1.5*2.54*cm+Al_Frame_Btm_Ground_Distance+Al_Frame_SideLength/2), Al_Frame_Square_Logic, "Al Main Frame Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(-Al_Frame_xPosition, 0., Al_Frame_zPosition), Al_Frame_LongBeam_Logic, "Al LongBeam Physical 1", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(Al_Frame_xPosition, 0., Al_Frame_zPosition), Al_Frame_LongBeam_Logic, "Al LongBeam Physical 2", fpWorldLogical, true, 1, true);
//-------------------------------------------------------------------------------------------
//---------------------SS Poles to Hold the Dewars-------------------------------------------
const G4double Front_Pole_Radius = 1.8/2*2.54*cm;
const G4double Side_Pole_Radius = 2/2*2.54*cm;
const G4double Front_Pole_Proton_Beam_Distance = 8*2.54*cm;
const G4double Side_Pole_Proton_Beam_Distance = 8*2.54*cm + 6.*cm;
const G4double Front_Pole_Height = TPC_Center_Ground_Distance+zAxis_TPC_Center_BeamLine_Distance-Front_Pole_Proton_Beam_Distance-Al_Frame_Btm_Ground_Distance-Al_Frame_SideLength;
const G4double Side_Pole_Height = TPC_Center_Ground_Distance+zAxis_TPC_Center_BeamLine_Distance-Side_Pole_Proton_Beam_Distance-Al_Frame_Btm_Ground_Distance-Al_Frame_SideLength;
const G4double Front_Pole_xPosition = 6*2.54*cm + Front_Pole_Radius + SSOuterDewar_OuterRadius;
const G4double Front_Pole_yPosition = 0.;
const G4double Front_Pole_zPosition = Al_Frame_zPosition+Al_Frame_SideLength/2+Front_Pole_Height/2;
const G4double Side_Pole_xPosition = 0.;
const G4double Side_Pole_yPosition = (Al_Frame_yAxis_Length - Al_Frame_SideLength)/2;
const G4double Side_Pole_zPosition = Al_Frame_zPosition+Al_Frame_SideLength/2+Side_Pole_Height/2;
G4Tubs *SS_Front_Pole = new G4Tubs("SS_Front_Pole", 0, Front_Pole_Radius, Front_Pole_Height/2, 0.*deg, 360*deg);
G4Tubs *SS_Side_Pole = new G4Tubs("SS_Side_Pole", 0, Side_Pole_Radius, Side_Pole_Height/2, 0.*deg, 360*deg);
G4LogicalVolume *SS_Front_Pole_Logic = new G4LogicalVolume(SS_Front_Pole, steel, "SS_Front_Pole_Logic");
G4LogicalVolume *SS_Side_Pole_Logic = new G4LogicalVolume(SS_Side_Pole, steel, "SS_Side_Pole_Logic");
SS_Side_Pole_Logic->SetVisAttributes(Al_Color);
SS_Front_Pole_Logic->SetVisAttributes(Al_Color);
new G4PVPlacement(0, G4ThreeVector(Front_Pole_xPosition, Front_Pole_yPosition, Front_Pole_zPosition), SS_Front_Pole_Logic, "Front Pole Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(-Front_Pole_xPosition, Front_Pole_yPosition, Front_Pole_zPosition), SS_Front_Pole_Logic, "Back Pole Physical", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(Side_Pole_xPosition, Side_Pole_yPosition, Side_Pole_zPosition), SS_Side_Pole_Logic, "Side Pole Physical 1", fpWorldLogical, true, 1, true);
new G4PVPlacement(0, G4ThreeVector(Side_Pole_xPosition, -Side_Pole_yPosition, Side_Pole_zPosition), SS_Side_Pole_Logic, "Side Pole Physical 2", fpWorldLogical, true, 1, true);
//-------------------------------------------------------------------------------------------
//===============================================
// Invisible world volume.
fpWorldLogical->SetVisAttributes(G4VisAttributes::Invisible);
//G4VisAttributes* PMT_Attributes = new G4VisAttributes(G4Colour::Blue());
//PMT_Attributes->SetForceSolid(true);
//===============================================
// Create the TPC & EJs sensitive detector
G4VSensitiveDetector* monitor = new BeamTestSensitiveDetector("Detector");
// Create Periphery Volumes sensitive detector
G4VSensitiveDetector* PeripheryDetector = new PeripherySensitiveDetector("PeripheryDetector");
// Register detector with manager
G4SDManager::GetSDMpointer()->AddNewDetector(monitor);
G4SDManager::GetSDMpointer()->AddNewDetector(PeripheryDetector);
///*
// Attach detector to volume defining calorimeter cells
ActiveGAr_Volume_Logical->SetSensitiveDetector(monitor);
ActiveLAr_Volume_Logical->SetSensitiveDetector(monitor);
EJ_tube_Logical->SetSensitiveDetector(monitor);
LAr_Volume_Logical->SetSensitiveDetector(PeripheryDetector);
GAr_Volume_Logical->SetSensitiveDetector(PeripheryDetector);
PTFE_BtmVolume_Logical->SetSensitiveDetector(PeripheryDetector);
PTFE_TopVolume_Logical->SetSensitiveDetector(PeripheryDetector);
QuartzWindow_Volume_Logical->SetSensitiveDetector(PeripheryDetector);
PMT_Shell_Logical->SetSensitiveDetector(PeripheryDetector);
PMT_QuartzWindow_Logical->SetSensitiveDetector(PeripheryDetector);
//*/
//---------------External Parts------------------
///*
// fpWorldLogical->SetSensitiveDetector(PeripheryDetector);
SSInnerDewar_CF600Flange_Logical->SetSensitiveDetector(PeripheryDetector);
SSInnerDewar_CF1650Flange_Logical->SetSensitiveDetector(PeripheryDetector);
SSInnerDewar_CF600FlangeRing_Logical->SetSensitiveDetector(PeripheryDetector);
SSOuterDewar_CF1650FlangeRing_Logical->SetSensitiveDetector(PeripheryDetector);
SSInnerDewar_Logical->SetSensitiveDetector(PeripheryDetector);
SSOuterDewar_Logical->SetSensitiveDetector(PeripheryDetector);
HoldingBar_Logical->SetSensitiveDetector(PeripheryDetector);
HeatExchanger_HoldingBar_Logical->SetSensitiveDetector(PeripheryDetector);
HeatExchanger_HoldingPlate_Logical->SetSensitiveDetector(PeripheryDetector);
HeatExchanger_Logical->SetSensitiveDetector(PeripheryDetector);
Coldhead_Flange_Logical->SetSensitiveDetector(PeripheryDetector);
Coldehead_TopBox_Logical->SetSensitiveDetector(PeripheryDetector);
Coldhead_Column_Logical->SetSensitiveDetector(PeripheryDetector);
Coldhead_Logical->SetSensitiveDetector(PeripheryDetector);
Coldhead_Cup_Logical->SetSensitiveDetector(PeripheryDetector);
EJ3_Shielding_Logical->SetSensitiveDetector(PeripheryDetector);
PE_Shielding_Logical->SetSensitiveDetector(PeripheryDetector);
SS_Side_Pole_Logic->SetSensitiveDetector(PeripheryDetector);
SS_Front_Pole_Logic->SetSensitiveDetector(PeripheryDetector);
Al_Frame_Square_Logic->SetSensitiveDetector(PeripheryDetector);
Al_Frame_LongBeam_Logic->SetSensitiveDetector(PeripheryDetector);
//delete SS_Color;
//*/
//===============================================
/*
////////////////////////////////////////////////////////////////////////
// Visualisation attributes
// Invisible world volume.
fpWorldLogical->SetVisAttributes(G4VisAttributes::Invisible);
// HandsOn4: Calorimeter attributes
// Invisible calorimeter mother volume
//calorimeterLogical->SetVisAttributes(G4VisAttributes::Invisible);
// Calorimeter cells - green with transparency
G4VisAttributes* calorimeterAttributes =
new G4VisAttributes(G4Colour(0.0, 1.0, 0.0, 0.1));
calorimeterAttributes->SetForceSolid(true);
//cellLogical->SetVisAttributes(calorimeterAttributes);
cellLogical->SetVisAttributes(G4VisAttributes::Invisible);
// Target Volume - light blue
G4VisAttributes* targetAttributes = new G4VisAttributes(G4Colour(0.0,0.5,0.5,1.0));
targetAttributes->SetForceSolid(true);
//targetLogical->SetVisAttributes(targetAttributes);
targetLogical->SetVisAttributes(G4VisAttributes::Invisible);
// Evacuation chamber - magenta
G4VisAttributes* evacChamberAttributes = new G4VisAttributes(G4Colour::Magenta());
evacChamberAttributes->SetForceSolid(true);
//evacChamberLogical->SetVisAttributes(evacChamberAttributes);
evacChamberLogical->SetVisAttributes(G4VisAttributes::Invisible);
// Silicon Monitor - cyan
G4VisAttributes* siliconMonitorAttributes = new G4VisAttributes(G4Colour::Cyan());
siliconMonitorAttributes->SetForceSolid(true);
//siliconMonitorLogical->SetVisAttributes(siliconMonitorAttributes);
siliconMonitorLogical->SetVisAttributes(G4VisAttributes::Invisible);
// Beam Pipe Vacuum - yellow
G4VisAttributes* beamPipeAttributes = new G4VisAttributes(G4Colour::Yellow());
beamPipeAttributes->SetForceSolid(true);
//beamPipeLogical->SetVisAttributes(beamPipeAttributes);
beamPipeLogical->SetVisAttributes(G4VisAttributes::Invisible);
*/
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2011 Opera Software ASA. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*/
#ifndef OP_INFOBAR_H
#define OP_INFOBAR_H
#include "adjunct/quick_toolkit/widgets/OpToolbar.h"
#include "modules/widgets/OpButton.h"
#include "modules/util/adt/opvector.h"
class PrefsFile;
class PrefsSection;
class OpButton;
class OpWindowCommander;
class OpToolbar;
/***********************************************************************************
**
** OpInfobar
**
***********************************************************************************/
class OpInfobar : public OpToolbar
{
protected:
OpInfobar(PrefsCollectionUI::integerpref prefs_setting = PrefsCollectionUI::DummyLastIntegerPref, PrefsCollectionUI::integerpref autoalignment_prefs_setting = PrefsCollectionUI::DummyLastIntegerPref);
virtual ~OpInfobar();
public:
static OP_STATUS Construct(OpInfobar** obj);
OP_STATUS Init(const char *toolbar_name);
void SetInfoImage(const char *image);
OP_STATUS SetInfoButtonActionString(OpString8& straction);
/**
* Return the name of the status field widget. Must be implemented by a subclass to have
* a unique name. Example: MyBar should use tbb_MyStatusText. The name must match with what
* is used in the resource files. The name is used by @ref SetStatusText and SetStatusTextWrap
* to look up the widget. Note: Legacy support allows this name not to be set but all new toolbars
* should set it.
*/
virtual const char* GetStatusFieldName() { return NULL; }
/**
* Return the name of the question field widget. Must be implemented by a subclass to have
* a unique name. Example: MyBar should use tbb_MyQuestionText. The name must match with what
* is used in the resource files. A valid name is mandatory for @ref SetQuestionText and
* ShowQuestionText to work
*/
virtual const char* GetQuestionFieldName() { return NULL; }
/**
* Set the status text. An OpStatusField widget named 'tbb_StatusText' is preferred, otherwise the
* first widget of type OpStatusField is used
*
* @param text. The text to set
* @return OpStatus::OK on success, OpStatus::ERR_NO_MEMORY on insufficent memory or OpStatus::ERR_NO_SUCH_RESOURCE
* if no widget could be located.
*/
OP_STATUS SetStatusText(OpStringC text);
/**
* Set a question or additional status text. An OpStatusField widget named 'tbb_QuestionText' is required
*
* @param text. The text to set
* @return OpStatus::OK on success, OpStatus::ERR_NO_MEMORY on insufficent memory or OpStatus::ERR_NO_SUCH_RESOURCE
* if no widget could be located.
*/
OP_STATUS SetQuestionText(OpStringC text);
/**
* Set wrapping (multi line messages) on or off for the status text fiel. An OpStatusField widget named
* 'tbb_QuestionText' is preferred, otherwise the first widget of type OpStatusField is used
*
* @param wrap TRUE (multi line) or FALSE (single line)
*/
void SetStatusTextWrap(BOOL wrap);
/**
* Show or hide the question or additional status text area.
*
* @param show TRUE (make field visible) or FALSE (hide field)
*/
void ShowQuestionText(BOOL show);
virtual void OnReadContent(PrefsSection *section);
virtual Type GetType() {return WIDGET_TYPE_INFOBAR;}
virtual BOOL Show() { return SetAlignmentAnimated(OpBar::ALIGNMENT_OLD_VISIBLE); }
virtual BOOL Hide() { return SetAlignment(OpBar::ALIGNMENT_OFF); }
BOOL AnimatedHide() { return SetAlignmentAnimated(OpBar::ALIGNMENT_OFF); }
#ifdef ACCESSIBILITY_EXTENSION_SUPPORT
virtual Accessibility::ElementKind AccessibilityGetRole() const {return Accessibility::kElementKindToolbar;}
#endif
private:
OP_STATUS CreateInfoButton();
protected:
OpString m_status_text;
OpString m_question_text;
OpButton * m_info_button;
BOOL m_wrap;
};
#endif // OP_TOOLBAR_H
|
#include <bits/stdc++.h>
#define MAX 100010
using namespace std;
int N, C, T;
int v[MAX];
int main()
{
ios_base::sync_with_stdio(false); cin.tie(0);
cin >> N >> C >> T;
int max=-1;
long int time = 0, acc = 0;
for(int i=0;i<N;i++){
cin >> v[i];
acc += v[i];
if(v[i] > max){
max = v[i];
}
time+=(int)ceil((double)v[i]/T);
}
int res = 0;
long int l = (int)ceil((double)max/T), r = time+10;
while(l < r){
long int mid = (r-l)/2 + l;
int counter = 0; acc = 0;
for(int i=0;i<N;i++){
acc += v[i];
if(acc > mid*T){
acc = v[i];
counter++;
}
}
if(acc >= v[N-1]){
counter++;
}
if(counter <= C){
r = mid;
res = mid;
}else{
l = mid+1;
if(l == r){
res = l;
}
}
}
cout << res << endl;
return 0;
}
|
#pragma once
#ifndef _REGISTER_H
#define _REGISTER_H
#include "stdafx.h"
using namespace std;
class registerFunc {
private:
typedef string DllNameType;
typedef vector<string> FunArgType;
typedef map<DllNameType, FunArgType> RegFunType;
public:
//注册函数所在的dll以及其中的被注册函数
static map<string, vector<string> > funReg;
private:
registerFunc() = default; //防止类被实例化
public:
static bool findFunc(string dllName,string funcNane);
static bool findDll(string dllName);
static bool regFunc(DllNameType DllName,FunArgType fArg);
static bool regDll();
};
#endif // !_REGISTER_H
|
/*****************************************************************
* Copyright (C) 2017-2018 Robert Valler - All rights reserved.
*
* This file is part of the project: DevPlatformAppCMake.
*
* This project can not be copied and/or distributed
* without the express permission of the copyright holder
*****************************************************************/
#ifndef IGUIOBJ_H
#define IGUIOBJ_H
class IGuiObj
{
public:
virtual ~IGuiObj(){}
virtual void guiObjSetPosition(float,float,float)=0;
virtual void guiObjSetDimension(int,int)=0;
virtual void guiObjSetType(unsigned int)=0;
virtual void guiObjEnd()=0;
};
#endif // IGUIOBJ_H
|
#include "headerc.h"
#include <iostream>
#include <sstream>
using namespace std;
class Box {
private:
long l;
long b;
long h;
public:
Box(): l(0), b(0), h(0) {}
Box(int length, int breadth, int height): l(length), b(breadth), h(height) {}
friend bool operator<(Box& a, Box& b) {
if (a.l < b.l) {
return true;
}
if ((a.b < b.b) && (a.l == b.l)) {
return true;
}
if ((a.h < b.h) && (a.b == b.b) && (a.l == b.l)) {
return true;
}
return false;
}
friend ostream& operator<<(ostream& out, Box& B) {
out << B.l << " " << B.b << " " << B.h;
return out;
}
// Return box's length
int getLength() {
return l;
}
// Return box's breadth
int getBreadth() {
return b;
}
// Return box's height
int getHeight() {
return h;
}
// Return the volume of the box
long long CalculateVolume() {
long long volume = l * b * h;
return volume;
}
};
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Opera test plugin.
*
* Library entry points.
*
* Copyright (C) 2011 Opera Software ASA.
*/
#include <algorithm>
#include <cassert>
#include "common.h"
/**
* Global library data.
*/
NPNetscapeFuncs* g_browser = 0;
bool g_crashed = false;
std::map<std::string, char*> g_cookies;
ObjectInstanceMap g_object_instance_map;
#ifdef XP_WIN
WindowInstanceMap g_window_instance_map;
#endif // XP_WIN
#ifdef XP_MACOSX
/**
* Required for Mac to make methods externally visible.
* This feels slightly wrong because npfunctions.h
* should theoretically take care of it (but it doesn't).
*/
extern "C"
{
NPError OSCALL NP_Initialize(NPNetscapeFuncs *browserFuncs);
NPError OSCALL NP_GetEntryPoints(NPPluginFuncs *pluginFuncs);
NPError OSCALL NP_Shutdown();
}
#endif // XP_MACOSX
/**
* Initialize and supply library with browser entry points.
*
* @See https://developer.mozilla.org/en/NP_Initialize.
*/
#if defined(XP_WIN) || defined(XP_MACOSX)
NPError OSCALL NP_Initialize(NPNetscapeFuncs* browser_functions)
{
if (!browser_functions)
return NPERR_INVALID_FUNCTABLE_ERROR;
#else // !XP_WIN && !XP_MACOSX
extern "C" NPError NP_Initialize(NPNetscapeFuncs* browser_functions, NPPluginFuncs* plugin_functions)
{
if (!browser_functions || !plugin_functions)
return NPERR_INVALID_FUNCTABLE_ERROR;
if (plugin_functions->size < sizeof(*plugin_functions))
return NPERR_INCOMPATIBLE_VERSION_ERROR;
initialize_plugin_function_structure(plugin_functions);
#endif // !XP_WIN && !XP_MACOSX
if (browser_functions->version < 21)
return NPERR_INCOMPATIBLE_VERSION_ERROR;
if (!(g_browser = static_cast<NPNetscapeFuncs*>(browser_functions->memalloc(sizeof(*g_browser)))))
return NPERR_OUT_OF_MEMORY_ERROR;
memset(g_browser, 0, sizeof(*g_browser));
/* Note parentheses around std::min to prevent macro expansion. */
memcpy(g_browser, browser_functions, (std::min)(static_cast<long unsigned int>(browser_functions->size),
static_cast<long unsigned int>(sizeof(*g_browser))));
return NPERR_NO_ERROR;
}
/**
* Make library release all resources.
*
* @See https://developer.mozilla.org/en/NP_Shutdown.
*/
#if defined(XP_UNIX) || defined(XP_GOGI)
extern "C" NPError OSCALL NP_Shutdown()
#else // !XP_UNIX && !XP_GOGI
NPError OSCALL NP_Shutdown()
#endif // !XP_UNIX && !XP_GOGI
{
for (std::map<std::string, char*>::iterator i = g_cookies.begin(); i != g_cookies.end(); ++i)
g_browser->memfree(i->second);
g_cookies.clear();
if (g_browser)
g_browser->memfree(g_browser);
return NPERR_NO_ERROR;
}
/**
* Called by browser to retrieve MIME types supported by this library.
*
* Not used on Windows, where the MIME type is read from the DLL version information.
*
* @See https://developer.mozilla.org/en/NP_GetMimeDescription.
*/
#if defined(XP_UNIX) || defined(XP_GOGI)
extern "C" const char* OSCALL NP_GetMIMEDescription()
{
return MIME_TYPE ":opera-test-plugin:Opera Test Plugin";
}
#endif // XP_UNIX || XP_GOGI
/**
* Called by browser to retrieve complete list of library entry points.
*
* Not used on UNIX, where the data is retrieved using NP_Initialize.
*
*/
#ifndef XP_UNIX
NPError OSCALL NP_GetEntryPoints(NPPluginFuncs* plugin_functions)
{
if (!plugin_functions)
return NPERR_INVALID_FUNCTABLE_ERROR;
initialize_plugin_function_structure(plugin_functions);
return NPERR_NO_ERROR;
}
#endif // !XP_UNIX
/**
* Called by browser to retrieve the name of this plugin.
*
* Not used on Windows, where the name resides in the DLL meta data.
*
*/
#if defined(XP_UNIX) || defined(XP_GOGI)
extern "C" NPError OSCALL NP_GetValue(void* /* future */, NPPVariable variable, void* value)
{
if (!value)
return NPERR_INVALID_PARAM;
switch (variable)
{
case NPPVpluginNameString:
*static_cast<char**>(value) = const_cast<char*>("Opera Test Plugin");
break;
case NPPVpluginDescriptionString:
*static_cast<char**>(value) = const_cast<char*>("Opera Test Plugin 1.2.0");
break;
case NPPVpluginNeedsXEmbed:
*static_cast<bool*>(value) = true;
break;
default:
return NPERR_INVALID_PARAM;
};
return NPERR_NO_ERROR;
}
#endif // XP_UNIX || XP_GOGI
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright 2002-2011 Opera Software ASA. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
** Peter Krefting
*/
#ifndef OPPREFSCOLLECTION_OVERRIDE_H
#define OPPREFSCOLLECTION_OVERRIDE_H
#include "modules/prefs/prefsmanager/opprefscollection.h"
#include "modules/prefs/prefsmanager/hostoverride.h"
#include "modules/url/url2.h" // for URL
class PrefsSection;
#ifdef PREFS_HOSTOVERRIDE
class OpOverrideHost;
class OverrideHost;
#endif
/**
* Preference collection with host override support.
*
* This implementation of the OpPrefsCollection class has support for
* overriding individual preferences based on host name. For preferences
* that are not overridden, the standard value will be returned as normal.
*
* OpPrefsCollectionWithHostOverride holds a list of OverrideHost objects,
* each object listing overrides for a particular host. Each OverrideHost
* holds a list of HostOverrideInt and HostOverrideString objects, which
* contain a single preference to be overridden. When a preference is
* looked up from OpPrefsCollectionWithHostOverride the list of override
* hosts is automatically searched (unless a NULL host is sent in).
*
* Changes in overrides are not relayed to the listeners.
*/
class OpPrefsCollectionWithHostOverride : public OpPrefsCollection
#ifdef PREFS_HOSTOVERRIDE
, protected OpOverrideHostContainer
#endif
{
public:
/** Destructor. */
virtual ~OpPrefsCollectionWithHostOverride() {}
#ifdef PREFS_HOSTOVERRIDE
/** Read overridden settings from the PrefsFile to internal storage.
* Interface implemented by sub-classes to perform the actual call to
* ReadOverridesInternalL(). Used by PrefsManager, called only once
* some time after creating the object and before the first call to
* any other use, once per host.
*
* @param host Host data is to be read for.
* @param section The preference section with overrides for the host.
* @param active Whether the overrides for this host are active or not.
* @param from_user Whether the overrides are entered by the user.
*/
virtual void ReadOverridesL(const uni_char *host, PrefsSection *section,
BOOL active, BOOL from_user) = 0;
# ifdef PREFS_WRITE
/** Remove all overrides for a named host. Used by PrefsManager, called
* if PrefsManager is requested to remove a host.
*
* @param host Host to delete overrides for.
*/
virtual void RemoveOverridesL(const uni_char *host);
# endif // PREFS_WRITE
// Implementation of OpPrefsCollection interfaces ---
virtual void SetOverrideReader(PrefsFile *reader);
virtual HostOverrideStatus IsHostOverridden(const uni_char *host, BOOL exact = TRUE);
size_t HostOverrideCount(const uni_char *host) const;
/** Enable or disable an overridden host. The name matching is always done
* exact.
*
* @param host Host to check for overrides.
* @param active Whether to activate the host.
* @return TRUE if a matching host was found.
*/
virtual BOOL SetHostOverrideActive(const uni_char *host, BOOL active = TRUE);
#endif // PREFS_HOSTOVERRIDE
protected:
/** Single-phase constructor.
*
* Inherited classes may have two-phase constructors if they wish.
*
* @param identity Identity of this collection (communicated by subclass).
* @param reader Pointer to the PrefsFile object.
*/
OpPrefsCollectionWithHostOverride(enum Collections identity, PrefsFile *reader)
: OpPrefsCollection(identity, reader)
#if defined PREFS_HOSTOVERRIDE && defined PREFS_READ
, m_overridesreader(NULL)
#endif
{};
#ifdef PREFS_HOSTOVERRIDE
/** Broadcast added, changed or removed host overrides to all listeners.
*
* @param hostname The host name for which the override was changed.
*/
virtual void BroadcastOverride(const uni_char *hostname);
#endif // PREFS_HOSTOVERRIDE
/** Interface used by sub-classes to read integer preferences. */
int GetIntegerPref(int which, const uni_char *host = NULL, BOOL *overridden = NULL) const;
/** Interface used by sub-classes to read integer preferences. */
int GetIntegerPref(int which, const uni_char *host, BOOL exact_match, BOOL *overridden = NULL) const;
/** Interface used by sub-classes to read string preferences. */
const OpStringC GetStringPref(int which, const uni_char *host = NULL, BOOL *overridden = NULL) const;
/** Interface used by sub-classes to read integer preferences. */
int GetIntegerPref(int which, const URL &host, BOOL *overridden = NULL) const;
/** Interface used by sub-classes to read string preferences. */
const OpStringC GetStringPref(int which, const URL &host, BOOL *overridden = NULL) const;
#ifdef PREFS_HOSTOVERRIDE
# ifdef PREFS_WRITE
/** Interface used by sub-classes to write overridden integer preferences.
* Overriding a preference automatically enables the override host.
*
* @param host Host to write an override for
* @param pref Pointer to the entry in the integerprefdefault structure
* for this preference. Used to get the strings to write to
* to the INI file.
* @param which Index for this preference (integer version of the
* enumeration used in OpPrefsCollection). Used for lookup.
* @param value Value for the override.
* @param from_user TRUE if the preference is entered by the user.
* @return ERR_NO_ACCESS if override is not allowed, OK otherwise.
*/
OP_STATUS OverridePrefL(
const uni_char *host,
const struct integerprefdefault *pref,
int which, int value, BOOL from_user);
/** Interface used by sub-classes to write overridden string preferences.
* Overriding a preference automatically enables the override host.
*
* @param host Host to write an override for
* @param pref Pointer to the entry in the stringprefdefault structure
* for this preference. Used to get the strings to write to
* to the INI file.
* @param which Index for this preference (integer version of the
* enumeration used in OpPrefsCollection). Used for lookup.
* @param value Value for the override.
* @param from_user TRUE if the preference is entered by the user.
* @return ERR_NO_ACCESS if override is not allowed, OK otherwise.
*/
OP_STATUS OverridePrefL(
const uni_char *host,
const struct stringprefdefault *pref,
int which, const OpStringC &value,
BOOL from_user);
# ifdef PREFS_HAVE_STRING_API
/** Override a site specific preference using the INI name. Should only
* be used from PrefsManager.
*/
virtual BOOL OverridePreferenceL(const uni_char *host, IniSection section,
const char *key, const OpStringC &value,
BOOL from_user) = 0;
/** Override a site specific preference using the INI name. Should only
* be used from PrefsManager.
*/
virtual BOOL RemoveOverrideL(const uni_char *host, IniSection section,
const char *key, BOOL from_user) = 0;
# endif // PREFS_HAVE_STRING_API
/** Remove an existing integer override for a named host.
*
* @param host Host to delete overrides for, or NULL to match all hosts.
* @param pref Pointer to the entry in the integerprefdefault structure
* for this preference. Used to get the strings to write to
* to the INI file.
* @param prefidx Index for this preference (integer version of the
* enumeration used in OpPrefsCollection). Used for lookup.
* @param from_user TRUE if the preference is entered by the user.
* @return TRUE if an override was found and removed.
*/
virtual BOOL RemoveIntegerOverrideL(const uni_char *host,
const struct integerprefdefault *pref,
int which,
BOOL from_user);
/** Remove an existing string override for a named host.
*
* @param host Host to delete overrides for, or NULL to match all hosts.
* @param pref Pointer to the entry in the stringprefdefault structure
* for this preference. Used to get the strings to write to
* to the INI file.
* @param prefidx Index for this preference (integer version of the
* enumeration used in OpPrefsCollection). Used for lookup.
* @param from_user TRUE if the preference is entered by the user.
* @return TRUE if an override was found and removed.
*/
virtual BOOL RemoveStringOverrideL(const uni_char *host,
const struct stringprefdefault *pref,
int which,
BOOL from_user);
# endif // PREFS_WRITE
/** Create an OpOverrideHostObject suitable for this collection. Usually, this
* creates the regular OverrideHost kind, but it is may be overridden for
* special collections.
*
* @param host Host name to create an object for.
* @param from_user Whether the overrides are entered by the user.
* @return The created object.
*/
virtual OpOverrideHost *CreateOverrideHostObjectL(const uni_char *host, BOOL from_user);
/**
* Check if integer preference is overridden for this host (internal).
*
* @param which Selects the preference to check.
* @param host Host context to check for override.
* @return TRUE if preference is overridden.
*/
BOOL IsIntegerOverridden(int which, const uni_char *host) const;
BOOL IsIntegerOverridden(int which, const URL &host) const;
/**
* Check if string preference is overridden for this host (internal).
*
* @param which Selects the preference to check.
* @param host Host context to check for override.
* @return TRUE if preference is overridden.
*/
BOOL IsStringOverridden(int which, const uni_char *host) const;
BOOL IsStringOverridden(int which, const URL &host) const;
# if defined PREFS_HAVE_STRING_API && defined PREFS_WRITE
BOOL OverridePreferenceInternalL(
const uni_char *host, IniSection section, const char *key,
const OpStringC &value, BOOL from_user,
const struct stringprefdefault *strings, int numstrings,
const struct integerprefdefault *integers, int numintegers);
BOOL RemoveOverrideInternalL(
const uni_char *host, IniSection section, const char *key, BOOL from_user,
const struct stringprefdefault *strings, int numstrings,
const struct integerprefdefault *integers, int numintegers);
# endif // PREFS_HAVE_STRING_API and PREFS_WRITE
#endif // PREFS_HOSTOVERRIDE
#ifdef PREFS_HAVE_STRING_API
BOOL GetPreferenceInternalL(IniSection section, const char *key,
OpString &target, BOOL defval, const uni_char *host,
const struct stringprefdefault *strings, int numstrings,
const struct integerprefdefault *integers, int numintegers);
#endif
#ifdef PREFS_HOSTOVERRIDE
/** Read all overrides for this domain from the preferences. Called from
* ReadAllOverridesL() in the sub-classes.
*
* @param host Host data is to be read for.
* @param section The prefs section with the data.
* @param active Whether the overrides for this host are active or not.
* @param from_user Whether the overrides are entered by the user.
* @param intprefs Pointer to the integerprefdefault structure.
* @param stringprefs Pointer to the stringprefdefault structure.
* @return TRUE if any overrides where found.
*/
void ReadOverridesInternalL(
const uni_char *host,
PrefsSection *section,
BOOL active, BOOL from_user,
const struct OpPrefsCollection::integerprefdefault *intprefs,
const struct OpPrefsCollection::stringprefdefault *stringprefs);
#endif
#if defined(PREFS_HOSTOVERRIDE) && defined(PREFS_READ)
/**
* Pointer to the preferences file object that override data is read
* from and written to. This object is owned by PrefsManager and is
* set when the overrides are first loaded.
*/
PrefsFile *m_overridesreader;
#endif // PREFS_HOSTOVERRIDE and PREFS_READ
};
#endif // OPPREFSCOLLECTION_OVERRIDE_H
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <climits>
int n, dp[256][256], minimum[256][256];
int solve(int s, int e)
{
if(s == e)
{
return 0;
}
int &ret = dp[s][e];
if(dp[s][e] != -1)
{
return ret;
}
ret = INT_MAX;
for(int i = s; i < e; i++)
{
ret = std::min(ret, solve(s, i) + solve(i + 1, e) + abs(minimum[s][i] - minimum[i + 1][e]));
}
return ret;
}
int main()
{
std::cin.sync_with_stdio(false);
std::cin.tie(NULL);
std::fill(dp[0], dp[0] + 256 * 256, -1);
std::cin >> n;
std::vector<int> list(n);
for(int i = 0; i < n; i++)
{
std::cin >> list[i];
}
for(int i = 0; i < n; i++)
{
for(int j = i; j < n; j++)
{
if(i == j)
{
minimum[i][j] = list[i];
}
else
{
minimum[i][j] = std::min(minimum[i][j - 1], list[j]);
}
}
}
std::cout << solve(0, n - 1) << '\n';
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
void swap(char *&s1,char *&s2)
{
char *tmp;
tmp = s1;
s1=s2;
s2=tmp;
}
void swap_pointer(char **s1,char **s2)
{
char *temp;
temp = *s1;
*s1=*s2;
*s2=temp;
}
int main()
{
char *a="hello";
char *b="ni hao";
// swap(a,b);
swap_pointer(&a,&b);
cout <<a<<endl;
cout<<b<<endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
int temp,i,n,d,r,cost;
vector<int>morn,nite;
while (1)
{
cost=0;
cin>>n>>d>>r;
if(n==0)break;
morn.clear();
for(i=0;i<n;i++)
{cin>>temp;morn.push_back(temp);}
nite.clear();
for(i=0;i<n;i++)
{cin>>temp;nite.push_back(temp);}
sort(morn.begin(),morn.end());
sort(nite.begin(),nite.end());
for(i=0;i<n;i++)
{
temp=(morn[i]+nite[n-i-1]-d);
if(temp>0)cost+=r*temp;
}
cout<<cost<<endl;
}
return 0;
}
|
/// C++ code to demonstrate working of remove() and
// remove_if()
//
#include<iostream>
#include<forward_list>
using namespace std;
int main()
{
// Initializing forward list
forward_list<int> flist = {10, 20,40, 30, 25, 40, 40};
// Removing element using remove()
// Removes all occurrences of 40
flist.remove(40);
// Displaying the forward list
cout << "The forward list after remove operation : ";
for (int&c : flist)
cout << c << " ";
cout << endl;
// Removing according to condition. Removes
// elements greater than 20. Removes 25 and 30
flist.remove_if([](int x){ return x>20;});
// Displaying the forward list
cout << "The forward list after remove_if operation : ";
for (int&c : flist)
cout << c << " ";
cout << endl;
return 0;
}
|
#pragma once
#using <mscorlib.dll>
#include "llvm/IR/Metadata.h"
#include "Value.h"
namespace LLVM
{
ref class LLVMContext;
ref class Value;
ref class Module;
ref class MDNode;
ref class raw_ostream;
ref class AssemblyAnnotationWriter;
public ref class MDString
: public Value
{
internal:
llvm::MDString *base;
protected:
MDString(llvm::MDString *base);
internal:
static inline MDString ^_wrap(llvm::MDString *base);
public:
!MDString();
virtual ~MDString();
static MDString ^get(LLVMContext ^Context, System::String ^Str);
System::String ^getString();
unsigned getLength();
// typedef StringRef::iterator iterator;
// iterator begin();
// iterator end();
static bool classof(Value ^V);
};
public ref class MDNode
: public Value
{
internal:
llvm::MDNode *base;
protected:
MDNode(llvm::MDNode *base);
internal:
static inline MDNode ^_wrap(llvm::MDNode *base);
public:
!MDNode();
virtual ~MDNode();
static MDNode ^get(LLVMContext ^Context, array<Value ^> ^Vals);
static MDNode ^getWhenValsUnresolved(LLVMContext ^Context, array<Value ^> ^Vals, bool isFunctionLocal);
static MDNode ^getIfExists(LLVMContext ^Context, array<Value ^> ^Vals);
static MDNode ^getTemporary(LLVMContext ^Context, array<Value ^> ^Vals);
static void deleteTemporary(MDNode ^N);
void replaceOperandWith(unsigned i, Value ^NewVal);
Value ^getOperand(unsigned i);
unsigned getNumOperands();
bool isFunctionLocal();
// const Function *getFunction();
// void Profile(FoldingSetNodeID &ID);
static bool classof(Value ^V);
static MDNode ^getMostGenericTBAA(MDNode ^A, MDNode ^B);
static MDNode ^getMostGenericFPMath(MDNode ^A, MDNode ^B);
static MDNode ^getMostGenericRange(MDNode ^A, MDNode ^B);
};
public ref class NamedMDNode
{
internal:
llvm::NamedMDNode *base;
protected:
NamedMDNode(llvm::NamedMDNode *base);
internal:
static inline NamedMDNode ^_wrap(llvm::NamedMDNode *base);
public:
!NamedMDNode();
virtual ~NamedMDNode();
void eraseFromParent();
void dropAllReferences();
inline Module ^getParent();
// inline const Module *getParent();
MDNode ^getOperand(unsigned i);
unsigned getNumOperands();
void addOperand(MDNode ^M);
System::String ^getName();
void print(raw_ostream ^ROS);
void print(raw_ostream ^ROS, AssemblyAnnotationWriter ^AAW);
void dump();
};
}
|
#include "dialogclass.h"
#include "ui_dialogclass.h"
DialogClass::DialogClass(QWidget *parent) :
QDialog(parent),
ui(new Ui::DialogClass)
{
ui->setupUi(this);
licenseArray = {"license1" , "license2"};
connect(this->ui->pushButton , SIGNAL(clicked(bool)) , this , SLOT(accept()));
}
DialogClass::~DialogClass()
{
delete ui;
}
QJsonObject DialogClass::returnData()
{
return informationObject;
}
void DialogClass::clear()
{
ui->nameEdit->clear();
ui->middleEdit->clear();
ui->lastEdit->clear();
ui->ageEdit->clear();
}
void DialogClass::accept()
{
informationObject.insert("name" , ui->nameEdit->text());
informationObject.insert("middleName" , ui->middleEdit->text());
informationObject.insert("lastName" , ui->lastEdit->text());
informationObject.insert("age" , ui->ageEdit->text().toInt());
informationObject.insert("license" , licenseArray);
QDialog::accept();
}
|
// 후위 표기법
/*
중위 표기식이 주어졌을 때 후위 표기식으로 고치고
계산값 출력하기
ex)
입력
2+3*(5+4*2)-3+6
출력
23542*+*+3-6+
*/
#include <iostream>
#include <string>
#include <vector>
#include <stack>
using namespace std;
vector<char> v; // 후위 수식을 담을 벡터
stack<char> st; // 연산자 스택
string infix; // 중위표기식
string postfix; // 후위표기식
//stack<int> st2; // 계산을 위한 stack
// stack 구현
////////////////
int Stack[101], top = -1;
void push(int x) {
Stack[++top] = x;
}
int empty() {
if (top < 0) return 1;
else return 0;
}
void pop() {
if (!empty()) Stack[top--] = 0;
}
char peek() {
if (!empty()) return Stack[top];
else return 0;
}
/////////////////
int getPriority(char op) {
if (op == '*' || op == '/') return 3;
if (op == '+' || op == '-') return 2;
if (op == '(') return 1;
//if (op >= '0' && op <= '9') return -1;
return -1;
}
void convertPostfix() {
for (int i = 0; i < infix.length(); i++) {
char ch = infix[i];
// 숫자
if (ch >= '0' && ch <= '9')
v.push_back(infix[i]);
else {
// '(' or 연산자 스택이 비어있으면
if (ch == '(' || st.empty())
st.push(ch);
// ')'
else if (ch == ')') {
char op = st.top();
st.pop();
while (op != '(') {
v.push_back(op);
op = st.top();
st.pop();
}
}
// '+', '-', '-', '/' :
// 현재 연산자가 연산자 스택의 탑보다 가중치가 높을 때
else if (getPriority(ch) > getPriority(st.top()))
st.push(ch);
// '+', '-', '-', '/' :
// 현재 연산자가 연산자 스택의 탑보다 가중치가 낮거나 같을 때
else {
while (!st.empty() &&
getPriority(ch) <= getPriority(st.top())) {
v.push_back(st.top());
st.pop();
}
st.push(ch);
}
}
}
// 스택 연산자의 남은 연산자 후위 표기식에 넣기
while (!st.empty()) {
v.push_back(st.top());
st.pop();
}
for (int i = 0; i < v.size(); i++)
postfix += v[i];
cout << "후위 표기식 : " << postfix << "\n";
}
int calcTwoOprd(int oprd1, int oprd2, char op) {
if (op == '+') return oprd1 + oprd2;
if (op == '-') return oprd1 - oprd2;
if (op == '*') return oprd1 * oprd2;
if (op == '/') return oprd1 / oprd2;
}
void caculate() {
for (int i = 0; i < postfix.length(); i++) {
char ch = postfix[i];
// 숫자
if (ch >= '0' && ch <= '9')
//st2.push(ch - '0');
push(ch - '0');
// 연산자
else {
//int op2 = st2.top();
//st2.pop();
//int op1 = st2.top();
//st2.pop();
//st2.push(calcTwoOprd(op1, op2, ch));
int op2 = peek();
pop();
int op1 = peek();
pop();
push(calcTwoOprd(op1, op2, ch));
}
}
//int ans = st2.top();
//st2.pop();
int ans = peek();
pop();
cout << "계산: " << ans << "\n";
}
int main() {
//cin >> express;
infix = "2+3*(5+4*2)-3+6";
// test
cout << "중위 표기식 : " << infix << "\n";
convertPostfix();
caculate();
return 0;
}
|
/*
===========================================================================
Copyright (C) 2017 waYne (CAM)
===========================================================================
*/
#pragma once
#ifndef ELYSIUM_GRAPHICS_PLATFORM_GAMEWINDOW
#define ELYSIUM_GRAPHICS_PLATFORM_GAMEWINDOW
#endif
#ifndef ELYSIUM_GRAPHICS_PLATFORM_IGAMECANVAS
#include "IGameCanvas.hpp"
#endif
#if defined(__ANDROID__)
#elif defined(_WIN32)
#ifndef _WINDEF_
#include <Windows.h>
#endif
#else
#error "undefined os"
#endif
namespace Elysium
{
namespace Graphics
{
namespace Platform
{
/// <summary>
/// ...
/// </summary>
class EXPORT GameWindow : public IGameCanvas, Object
{
friend class GameHost;
public:
// constructors & destructor
GameWindow();
~GameWindow();
// properties - getter
#if defined(__ANDROID__)
#elif defined(_WIN32)
virtual HWND GetHWND() override;
#else
#error "undefined os"
#endif
// methods
virtual void Show() override;
virtual void Close() override;
private:
// fields
bool _ShouldExit = false;
// methods
void ProcessInput(); // ToDo: let's keep this here for now. we might want to do this in some sort if inputmanager though eventually
#if defined(__ANDROID__)
#elif defined(_WIN32)
// fields
HWND _Window = nullptr;
// methods
static LRESULT WindowCallbackProcedure(HWND WindowHandle, unsigned int Message, WPARAM wParam, LPARAM lParam);
int Process(HWND WindowHandle, unsigned int Message, WPARAM wParam, LPARAM lParam);
#else
#error "undefined os"
#endif
};
}
}
}
|
#include "PhotonBox/component/DirectionalLight.h"
#include "PhotonBox/resource/FrameBuffer.h"
#include "PhotonBox/core/system/Lighting.h"
#include "PhotonBox/core/system/Renderer.h"
#include "PhotonBox/resource/shader/DefaultPostShader.h"
#include "PhotonBox/resource/shader/DirectionalShadowShader.h"
#include "PhotonBox/resource/shader/ForwardDirectionalLightShader.h"
#ifdef PB_MEM_DEBUG
#include "PhotonBox/util/MEMDebug.h"
#define new DEBUG_NEW
#endif
void DirectionalLight::init()
{
Lighting::addLight(this);
lightProjection = Matrix4f::createOrthographic(-5.0f, 5.0f, -5.0f, 5.0f, 0.1f, 100.0f);
}
DirectionalLight::~DirectionalLight()
{
//shadowBuffer->clear();
}
void DirectionalLight::destroy()
{
Lighting::removeLight(this);
}
Shader* DirectionalLight::getLightShader()
{
return ForwardDirectionalLightShader::getInstance();
}
/*
void DirectionalLight::renderShadowMap(bool captureMode)
{
shadowBuffer->enable();
shadowBuffer->clear();
//Renderer::render(_depthShader, captureMode);
if(!captureMode){
ImGui::Begin("Depth");
ImGui::Image((ImTextureID)shadowBuffer->getAttachment("depth")->id, ImVec2(_shadowMapResolution/15.0f, _shadowMapResolution/15.0f), ImVec2(0, 1), ImVec2(1, 0));
ImGui::End();
}
//FrameBuffer::resetDefaultBuffer();
}
*/
void DirectionalLight::OnEnable()
{
Lighting::addLight(this);
}
void DirectionalLight::OnDisable()
{
Lighting::removeLight(this);
}
|
#include<iostream>
#include<cstdio>
#include<map>
#include<set>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<cstring>
#include<sstream>
#include<algorithm>
#include<cmath>
#define INF 0x3f3f3f3f
#define eps 1e-8
#define pi acos(-1.0)
using namespace std;
typedef long long LL;
int f[200100],a[200100];
stack<int> S;
int find(int k) {
while (f[k] != k) {
S.push(k);
k = f[k];
}
while (!S.empty()) {
int p = S.top();S.pop();
f[p] = k;
}
return k;
}
int main() {
int n,k,root = 0;
scanf("%d",&n);
for (int i = 1;i <= n; i++) f[i] = i;
for (int i = 1;i <= n; i++) {
scanf("%d",&a[i]);
if (root == 0 && i == a[i]) root = a[i];
int x = find(i),y = find(a[i]);
if (x != y) f[x] = y;
}
int ans = 0;
for (int i = 1;i <= n; i++)
if (f[i] == i && f[i] != root) {
ans++;
if (root) a[i] = root;
else a[i] = root = i;
}
//cout << root <<endl;
printf("%d\n",ans);
for (int i = 1;i < n; i++) printf("%d ",a[i]);
printf("%d\n",a[n]);
return 0;
}
|
//
// EnemyRBullet.cpp
//
// Created by Yajun Shi
//
#include "EnemyRBullet.h"
#include "Player.h"
EnemyRBullet::EnemyRBullet(Enemy* enemy){
Vector2 enemyVector = MathUtil::VectorFromAngle(enemy->GetRotation() + 90.0f);
Vector2 pos = enemy->GetPosition();
pos -= enemyVector * (enemy->GetSize().Y * 0.5f);
SetPosition(pos);
SetSize(0.5f);
SetDensity(1.0f);
SetIsSensor(true);
SetSprite("./Resources/Images/enemyBullet.png");
SetShapeType(PhysicsActor::SHAPETYPE_CIRCLE);
InitPhysics();
GetBody()->SetBullet(true);
ApplyLinearImpulse(Vector2(1.0f, -1.0f), Vector2::Zero);
Tag("enemyBullet");
theWorld.Add(this);
}
|
//------------------------------------------------------------------------------
/*
This file is part of Beast: https://github.com/vinniefalco/Beast
Copyright Patrick Dehne <patrick@mysonicweb.de> (www.sonicweb-radio.de)
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#ifndef BEAST_VFLIB_MANUALSERVICEQUEUE_H_INCLUDED
#define BEAST_VFLIB_MANUALSERVICEQUEUE_H_INCLUDED
#include "CallQueue.h"
namespace beast {
class ManualServiceQueue
: public CallQueue
{
public:
explicit ManualServiceQueue (const String& name)
: CallQueue(name)
{
}
/** Calls all functors in the queue. Returns if there are no
more functors available to run
*/
bool synchronize ()
{
if(poll() > 0)
return true;
return false;
}
};
//------------------------------------------------------------------------------
namespace detail
{
//------------------------------------------------------------------------------
class ManualServiceQueueTests
: public UnitTest
{
public:
struct CallTracker
{
ManualServiceQueueTests *unitTest;
int c0, c1;
int q0, q1;
CallTracker(ManualServiceQueueTests *parent)
: unitTest(parent)
, c0(0), c1(0)
, q0(0), q1(0)
{
}
void doQ0() { q0++; }
void doQ1(const String& p1)
{
unitTest->expect(p1 == "p1");
q1++;
}
void doC0() { c0++; }
void doC1(const String& p1)
{
unitTest->expect(p1 == "p1");
c1++;
}
};
void performEmptyQueue()
{
beginTestCase("Empty queue");
ManualServiceQueue queue("ManualServiceQueueTests");
bool doneSomething = queue.synchronize();
expect(!doneSomething);
queue.close();
}
void performCalls()
{
beginTestCase("Calls");
Random r;
r.setSeedRandomly();
ManualServiceQueue queue("ManualServiceQueueTests");
static int const batches = 1000;
for(std::size_t i=0; i<batches; i++)
{
CallTracker ct(this);
std::size_t batchSize = r.nextLargeNumber(10).toInteger();
if(batchSize > 0)
{
for(std::size_t y=0; y<batchSize; y++)
{
int callType = r.nextLargeNumber(10).toInteger();
if(callType % 2)
{
queue.queue(&CallTracker::doQ0, &ct);
queue.call(&CallTracker::doC0, &ct);
}
else
{
queue.queue(&CallTracker::doQ1, &ct, "p1");
queue.call(&CallTracker::doC1, &ct, "p1");
}
}
bool doneSomething = queue.synchronize();
expect(doneSomething);
expect ((ct.q0 + ct.q1) == batchSize);
expect ((ct.c0 + ct.c1) == batchSize);
doneSomething = queue.synchronize();
expect(!doneSomething);
}
}
queue.close ();
}
void runTest()
{
performEmptyQueue ();
performCalls ();
}
ManualServiceQueueTests () : UnitTest ("ManualServiceQueue", "beast")
{
}
};
}
}
#endif
|
#include "punto.h"
razionale punto::getX() const {return x;}
razionale punto::getY() const {return y;}
bool punto::operator ==(const punto& p){
if((p.getX() == getX()) && (p.getY()) == getY()){
return true;
}
else return false;
}
double punto::distanceTwoPoints(const punto& p1) const{
return sqrt(pow((x-p1.x),2)+pow((y-p1.y),2));
}
double punto::distance(inputitem * i) const {
if(typeid(*i) == typeid(retta)){
return i->distance(const_cast<punto*>(this));
}
else if( typeid(punto) == typeid(*i) ){
return distanceTwoPoints(*(dynamic_cast<punto*>(i)));
}
else return i->distance(const_cast<punto*>(this));
}
ostream& operator<<(ostream& buffer, const punto& p){
return buffer<<"("<<p.x<<";"<<p.y<<")";
}
void punto::pars_point(string p){
//rimuove gli spazi
unsigned int len = p.length();
for (unsigned int var = 0; var < len; ++var) {
if(p[var] == ' '){
p.erase(p.begin()+var);
var--;
len--;
}
}
string s;
double n=0,d=1;
int sign=1;
//verifico se è un double
bool doub = false;
double virgola = 1 , n1;
//virgola vale : 10 se ho un numero dopo la virgola ,100 se ho due punti dopo la virgola , 1000 se ho tre punti dopo la virgola
for(unsigned int cont = 0 ; cont < p.length() ; ++cont){
if(p[cont] != '('){
if(p[cont] == '-' || p[cont] == '+'){
if(p[cont] == '-' && sign == -1 )
sign = 1;
else if(p[cont] == '-')
sign = -1;
}
else if(p[cont] == '/'){
if(s.length() == 0) throw input_error("Manca il numeratore.");
if(doub) {
n1 = std::stoi( s );
n = n1 / virgola;
}
else n = std::stoi( s );
doub = false;
virgola = 1;
if( n == 0 ){
while( p[cont] != ';' && p[cont] != ')' )
cont++;
if(p[cont] == ';')
x = razionale(0,1);
else
y = razionale(0,1);
}
s.erase(s.begin(),s.end());
}
else if(p[cont] == ';' || p[cont] == ')'){
if(s.length() == 0){
throw input_error("Errore: manca un input.");
}
if(n != 0){
if(doub){
n1 = std::stoi( s );
d = n1 / virgola;
}
else d = std::stoi( s );
doub = false;
virgola = 1;
if( d == 0 ) throw input_error("Errore al denominatore.");
}else{
if(doub) {
n1 = std::stoi( s );
n = n1 / virgola;
}
else n = std::stoi( s );
virgola = 1 ;
doub = false;
d = 1;
}
if(p[cont] == ';'){
x = razionale(n*sign,d);
}
else{
y = razionale(n*sign,d);
//è finito il punto perchè sono ')'
break;
}
d=1;n=0;
s.erase(s.begin(),s.end());
sign = 1;
}
else{
//p[cont] e' un valore numerico
std::locale loc;
if(p[cont] == '.'){
doub = true;
}
else if(isdigit(p[cont],loc))
{
if(doub) virgola *= 10 ;
s = s+p[cont];
}
else {
throw input_error("Errore: valore non numerico.");
}
}
}
}
if(p[0] == '(' && p[p.length()-1] == ')') {
throw 1;
}
else throw input_error("Errore: mancano le parentesi.");
}
double punto::xToDouble() const{
return x.converti();
}
double punto::yToDouble() const{
return y.converti();
}
//serve per la gui
string punto::toString(){
std::string st ;
st = st + x.tostring() + ";" + y.tostring();
return st;
}
vector<punto> punto::intersect( inputitem* i ) const {
vector<punto> punt;
if(typeid(*i) == typeid(punto)){
punto * p = dynamic_cast<punto*>(i);
if( distanceTwoPoints(*p) == 0 ) {
punt.push_back(*p);
}
return punt;
}
//rilancio la chiamata cambiando l'oggetto di invocazione
return i->intersect(const_cast<punto*>(this));
}
|
#include "stick.h"
void Stick::unlock()
{
m.unlock();
}
bool Stick::try_lock()
{
return m.try_lock();
}
|
#pragma once
#pragma unmanaged
#include <BWAPI\Region.h>
#include <BWAPI\Regionset.h>
#pragma managed
#include "IIdentifiedObject.h"
#include "Position.h"
using namespace System::Collections::Generic;
using namespace System::Drawing;
namespace BroodWar
{
namespace Api
{
public ref class Region sealed : public IIdentifiedObject
{
internal:
BWAPI::Region instance;
Region(BWAPI::Region region);
public:
virtual property int Id { int get(); }
property int RegionGroupId { int get(); }
property Position^ Center { Position^ get(); }
property bool IsHigherGround { bool get(); }
property int DefensePriority { int get(); }
property bool IsAccessible { bool get(); }
property HashSet<Region^>^ Neighbours { HashSet<Region^>^ get(); }
property System::Drawing::Rectangle Bounds { System::Drawing::Rectangle get(); }
property Region^ ClosestAccessibleRegion { Region^ get(); }
property Region^ ClosestInaccessibleRegion { Region^ get(); }
int DistanceTo(Region^ region);
virtual int GetHashCode() override;
virtual bool Equals(Object^ o) override;
bool Equals(Region^ other);
static bool operator == (Region^ first, Region^ second);
static bool operator != (Region^ first, Region^ second);
};
Region^ ConvertRegion(BWAPI::Region region);
}
}
|
#include "ResultsReader.h"
ResultsReader::ResultsReader(){
data_read = false;
target_read = false;
data_normalized = false;
distances_computed = false;
n_threads = 0;
n_stats = 0;
n_params = 0;
min_distance = 1000000;
max_distance = 0.0;
cut_distance = 0.0;
}
ResultsReader::~ResultsReader(){
}
void ResultsReader::readThreadsData(string &output_base, unsigned int _n_threads, unsigned int _n_stats, unsigned int _n_params){
data_read = true;
n_threads = _n_threads;
n_stats = _n_stats;
n_params = _n_params;
unsigned int buff_size = 1020*1024;
char buff[buff_size];
fstream lector;
double value = 0;
// Cargar todos los resultados de este feedback
cout << "ResultsReader::readThreadsData - Leyendo resultados (n_threads: " << n_threads << ", n_stats: " << n_stats << ", n_params: " << n_params << ")\n";
for(unsigned int pid = 0; pid < n_threads; ++pid){
string file_name = output_base;
file_name += std::to_string(pid);
file_name += ".txt";
lector.open(file_name, fstream::in);
if( ! lector.is_open() ){
cerr << "ResultsReader::readThreadsData - Problemas al abrir archivo \"" << file_name << "\"\n";
continue;
}
cout << "ResultsReader::readThreadsData - Cargando datos de \"" << file_name << "\"\n";
while(true){
lector.getline(buff, buff_size);
if( !lector.good() || strlen(buff) < 1 ){
break;
}
string line(buff);
stringstream toks(line);
vector<double> res_stats;
vector<double> res_stats_norm;
for(unsigned int i = 0; i < n_stats; ++i){
value = 0.0;
toks >> value;
res_stats.push_back(value);
res_stats_norm.push_back(value);
}
stats.push_back(res_stats);
stats_norm.push_back(res_stats_norm);
vector<double> res_params;
for(unsigned int i = 0; i < n_stats; ++i){
value = 0.0;
toks >> value;
res_params.push_back(value);
}
params.push_back(res_params);
}
lector.close();
}
}
void ResultsReader::setTarget(string &target_file){
target_read = true;
unsigned int buff_size = 1020*1024;
char buff[buff_size];
fstream lector;
double value = 0;
cout << "ResultsReader::setTarget - Cargando target de \"" << target_file << "\"\n";
lector.open(target_file, ifstream::in);
if( ! lector.is_open() ){
cerr << "ResultsReader::setTarget - Problemas al abrir archivo\n";
return;
}
else{
lector.getline(buff, buff_size);
//Linea valida de largo > 0
string line(buff);
stringstream toks(line);
// stats
for(unsigned int i = 0; i < n_stats; ++i){
value = 0.0;
toks >> value;
target.push_back( value );
}
cout << "Target: ";
for(unsigned int i = 0; i < target.size(); ++i){
cout << target[i] << " | ";
}
cout << "\n";
}
lector.close();
}
// Normaliza tanto los datos como el target
void ResultsReader::normalize(){
assert( data_read == true);
assert( target_read == true);
data_normalized = true;
double value = 0;
cout << "ResultsReader::normalize - Calculando minimos y maximos por stat\n";
// Inicializo con los valores del target y busco en los resultados
for( double d : target ){
min_stats.push_back(d);
max_stats.push_back(d);
}
unsigned int procesados = 0;
for( vector<double> &res_stats : stats ){
++procesados;
for(unsigned int i = 0; i < res_stats.size(); ++i){
value = res_stats[i];
if( value < min_stats[i] ){
min_stats[i] = value;
}
if( value > max_stats[i] ){
max_stats[i] = value;
}
}
}
cout << "ResultsReader::normalize - Procesados para min/max: " << procesados << "\n";
// Verificacion
cout << "Min: ";
for(unsigned int i = 0; i < n_stats; ++i){
cout << min_stats[i] << " | ";
}
cout << "\n";
cout << "Max: ";
for(unsigned int i = 0; i < n_stats; ++i){
cout << max_stats[i] << " | ";
}
cout << "\n";
cout << "ResultsReader::normalize - Normalizando target y stats de resultados\n";
for(unsigned int i = 0; i < target.size(); ++i){
target[i] = (target[i] - min_stats[i]);
if( max_stats[i] != min_stats[i] ){
target[i] /= (max_stats[i] - min_stats[i]);
}
}
for( vector<double> &res_stats : stats_norm ){
for(unsigned int i = 0; i < res_stats.size(); ++i){
res_stats[i] = (res_stats[i] - min_stats[i]);
if( max_stats[i] != min_stats[i] ){
res_stats[i] /= (max_stats[i] - min_stats[i]);
}
}
}
// Verificacion
// cout << "Target: ";
// for(unsigned int i = 0; i < n_stats; ++i){
// cout << target[i] << " | ";
// }
// cout << "\n";
// for(unsigned int k = 0; k < 10 && k < stats.size(); ++k){
// cout << "Res[" << k << "]: ";
// for(unsigned int i = 0; i < n_stats; ++i){
// cout << stats[k][i] << " | ";
// }
// cout << "\n";
// cout << "Res_norm[" << k << "]: ";
// for(unsigned int i = 0; i < n_stats; ++i){
// cout << stats_norm[k][i] << " | ";
// }
// cout << "\n";
// }
}
// Calcula la distancia de cada dato normalizado al target
void ResultsReader::computeDistances(){
assert( data_normalized == true);
distances_computed = true;
unsigned int pos = 0;
for( vector<double> &res_stats : stats_norm ){
double d = 0.0;
for(unsigned int i = 0; i < target.size(); ++i){
d += pow( res_stats[i] - target[i], 2.0 );
}
d = pow(d, 0.5);
distancias.push_back( pair<double, unsigned int>(d, pos++) );
if( d > max_distance ){
max_distance = d;
}
if( d < min_distance ){
min_distance = d;
}
}
for(unsigned int i = 0; i < distancias.size(); ++i){
distancias[i].first /= max_distance;
}
}
// Ordena por distancia y selecciona los mejores resultados para el training
void ResultsReader::selectBestResults(double f_training){
assert( distances_computed == true);
double value = 0.0;
sort(distancias.begin(), distancias.end());
// Verificacion
for(unsigned int k = 0; k < 10 && k < distancias.size(); ++k){
cout << "Distancia[" << k << "]: (" << distancias[k].first <<", " << distancias[k].second <<")\n";
}
cout<<"-----\n";
// Verificacion
for(unsigned int k = 0; k < 10 && k < distancias.size(); ++k){
unsigned int pos = distancias.size() - k - 1;
cout << "Distancia[" << pos << "]: (" << distancias[pos].first <<", " << distancias[pos].second <<")\n";
}
cout<<"-----\n";
// Seleccion efectiva de resultados
unsigned int topk = (unsigned int)(f_training * distancias.size());
if( topk < 10 ){
topk = ((10<distancias.size())?10:distancias.size());
}
cut_distance = distancias[topk].first * max_distance;
cout << "ResultsReader::selectBestResults - Topk: " << topk << " / " << distancias.size() << "\n";
for(unsigned int i = 0; i < n_params; ++i){
vector<double> sample;
samples.push_back(sample);
}
for(unsigned int i = 0; i < topk; ++i){
unsigned int pos_res = distancias[i].second;
for(unsigned int j = 0; j < n_params; ++j){
value = params[pos_res][j];
samples[j].push_back(value);
}
}
}
// Retorna pares <mean, stddev> de cada parametro calculado de los datos seleccionados
vector< pair<double, double> > ResultsReader::getPosteriori(){
vector< pair<double, double> > res;
// Calculo de estadisticos reales
for(unsigned int i = 0; i < samples.size(); ++i){
double mean = getMean(samples[i]);
double median = getMedian(samples[i]);
double variance = getVariance(samples[i], mean);
double stddev = pow(variance, 0.5);
cout << "Statistics - Posteriori[" << i << "]: (mean: " << mean << ", median: " << median << ", variance: " << variance << ", stddev: " << stddev << ")\n";
// writer << "Posteriori[" << i << "]: mean: " << mean << " | median: " << median << " | variance: " << variance << " | stddev: " << stddev << "\n";
res.push_back( pair<double, double>(mean, stddev) );
}
return res;
}
double ResultsReader::getMean(vector<double> &data){
if( data.size() < 1 ){
return 0.0;
}
double suma = 0.0;
for(unsigned int i = 0; i < data.size(); ++i){
suma += data[i];
}
return suma/data.size();
}
// Notar que realizo una copia local de data para ordenarlo sin modificar los originales
double ResultsReader::getMedian(vector<double> &data){
if( data.size() < 1 ){
return 0.0;
}
double median;
vector<double> copia = data;
size_t size = copia.size();
sort(copia.begin(), copia.end());
// Si es par, promedio los dos elementos medios
if( (size % 0x1) == 0 ){
median = copia[ (size / 2) - 1 ] + copia[ size / 2 ];
median /= 2.0;
}
else{
median = copia[ size / 2 ];
}
return median;
}
// Si se recibe mean, se usa. De otro modo, se calcula.
double ResultsReader::getVariance(vector<double> &data, double mean){
if( data.size() < 1 ){
return 0.0;
}
double suma = 0.0;
for(unsigned int i = 0; i < data.size(); ++i){
suma += pow(data[i] - mean, 2.0);
}
return suma/data.size();
}
|
#include <string.h>
#include "vsop.h"
#include "tree/headers/AstNode.hpp"
void yyerror(char *s);
extern FILE *yyin;
extern int yylex_call(char *fileName);
using namespace std;
int main(int argc, char **argv) {
// LEXICAL ANALYSIS
if (argv[1] && strcmp(argv[1], "-lex") == 0)
return yylex_call(argv[2]);
bool ext = false;
string filename;
if (argv[2]){
if(argv[3] && strcmp(argv[2], "-ext") == 0){
ext = true;
filename = argv[3];
}
else
filename = argv[2];
}
FILE *pFile;
pFile = fopen(filename.c_str(), "r");
if (pFile == nullptr)
perror("Error opening file");
yyin = pFile;
AstNode *root = parser(ext, filename);
// SYNTAX ANALYSIS
if (argv[1] && strcmp(argv[1], "-parse") == 0) {
root->printTree();
fclose(pFile);
return EXIT_SUCCESS;
}
// SEMANTIC ANALYSIS
if (argv[1] && strcmp(argv[1], "-check") == 0) {
string retString = root->printCheck();
if (retString.find("ErrorSemanticOneTime") != string::npos) {
while (retString.find("ErrorSemanticOneTime") != string::npos)
retString.replace(retString.find("ErrorSemanticOneTime"), 20, filename);
cerr << retString << "\n";
exit(EXIT_FAILURE);
}
printf("%s", retString.c_str());
}
fclose(pFile);
return EXIT_SUCCESS;
}
|
#include<iostream>
#define GGMU 0
using namespace std;
class theGrandDad
{
public:
float h;
public:
theGrandDad():h(0) { cout << "Default Grandad\n"; }
theGrandDad(int n):h(n) {cout << "Power GranDad :" + n << "\n"; }
virtual void theFunction()
{
cout << "Generation Power:" << cout.width(5) << h<<endl;
}
void theRepeater(){theFunction();}
void theAlternate()
{
cout<<"I'm in theGrandDad\n";
}
};
class theDad:virtual public theGrandDad
{
public:
theDad(){h = 100; cout << "Default Dad\n"; }
theDad(int n) { h=n; cout << "Power Dad: " << n << "\n"; }
void theAlternate()
{
cout << "I'm in theDad\n";
}
virtual void theFunction()
{
cout << "Dad\n";
}
};
class theMom :virtual public theGrandDad
{
public:
theMom() { h = 1; cout << "Default Mom\n"; }
theMom(int n) { h = n; cout << "Power Mom: " << n << "\n"; }
};
class theChild : public theMom, public theDad
{
private:
public:
theChild()
{
cout << "Default Child\n";
}
theChild(int n) :theDad(n), theMom(n) { cout << "Child Power: " << theDad::h + theMom::h<<endl; }
void theFunction(){ cout << "grandChild\n";}
void theAlternate()
{
cout << "I'm in theChild\n";
}
};
//int main()
//{
// theGrandDad* gdad;
// theMom* dad;
//
// theChild obj;
// cout << endl;
// theChild obj2(5);
//
// dad = &obj;
// gdad = dad;
//
// cout << endl;
// //obj.theGrandDad::theFunction();
// (*gdad).theFunction();
// gdad->theAlternate();
// cout << endl;
//
// gdad = &obj;
// (*gdad).theFunction();
// gdad->theAlternate();
// cout << endl;
// theGrandDad* gdad2;
// theMom dad2;
//
// gdad2 = &dad2;
//
// gdad2->theGrandDad::theFunction();
// dad2.theRepeater();
//
// return GGMU;
//}
|
/*
* CriticalSection.h
*
* Created on: Jan 16, 2019
* Author: juniper
*/
#ifndef UTILITY_CRITICALSECTION_H_
#define UTILITY_CRITICALSECTION_H_
#include <pthread.h>
#include "Time.h"
#include <time.h>
class CriticalSection {
public:
inline CriticalSection() noexcept
{
mutex_ = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
attr_ = (pthread_mutexattr_t*) malloc(sizeof(pthread_mutexattr_t));
pthread_mutexattr_init(attr_);
pthread_mutexattr_settype(attr_, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(mutex_, attr_);
}
inline ~CriticalSection() noexcept
{
pthread_mutex_destroy(mutex_);
free(mutex_);
free(attr_);
}
inline void enter() noexcept
{
pthread_mutex_lock(mutex_);
}
inline bool tryEnter() noexcept
{
int ret = pthread_mutex_trylock(mutex_);
if (ret == 0) {
return true;
} else {
return false;
}
}
inline void exit() noexcept
{
pthread_mutex_unlock(mutex_);
}
private:
pthread_mutex_t* mutex_;
pthread_mutexattr_t* attr_;
};
class ScopedLock {
public:
inline ScopedLock(CriticalSection& section)
: criticalSection_(section)
{
criticalSection_.enter();
}
inline ~ScopedLock() {
criticalSection_.exit();
}
private:
CriticalSection& criticalSection_;
};
class WaitableEvent {
public:
inline WaitableEvent(bool manualReset = false) noexcept
{
pthread_cond_init(&cv_, NULL);
}
inline ~WaitableEvent()
{
}
inline bool wait(int timeOutMilliseconds = -1) noexcept
{
struct timespec timeToWait;
int ret = 0;
clock_gettime(CLOCK_REALTIME, &timeToWait);
timeToWait.tv_nsec += timeOutMilliseconds * 1000;
timeToWait.tv_sec = (timeToWait.tv_nsec + 1000UL * timeOutMilliseconds) * 1000UL;
pthread_mutex_lock(&mutex_);
while (!signaled_ && ret == 0) {
ret = pthread_cond_timedwait(&cv_, &mutex_, &timeToWait);
}
pthread_mutex_unlock(&mutex_);
return true;
}
inline void signal() noexcept
{
signaled_ = true;
pthread_cond_signal(&cv_);
}
inline void reset() noexcept
{
signaled_ = false;
}
private:
bool signaled_ = false;
pthread_cond_t cv_;
pthread_mutex_t mutex_ = PTHREAD_MUTEX_INITIALIZER;
inline double currentTime()
{
return Time::getMillisecondCounterHiRes();
}
};
#endif /* UTILITY_CRITICALSECTION_H_ */
|
int buzzer = 7;
int frequency = 900;
int PIR_sensor = A5;
int val = 0;
void setup() {
pinMode(buzzer,OUTPUT);
pinMode(PIR_sensor, INPUT);
Serial.begin(9600);
}
void loop() {
val = analogRead(PIR_sensor); //读取A0口的电压值并赋值到val
Serial.println(val);
if(val > 300){
tone(buzzer,frequency);
delay(500);
noTone(buzzer);
delay(500);
}
}
|
/*1069*/
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cassert>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <list>
#include <queue>
#include <set>
#include <cstdlib>
#include <cmath>
using namespace std;
class Block
{
public:
int x, y, z;
Block()
{
x = 0;
y = 0;
z = 0;
}
Block(int x, int y, int z):
x(x), y(y), z(z){ }
class Pred
{
public:
bool operator()(const Block &l, const Block &r)
{
if (l.x == r.x)
{
return l.y > r.y;
}
else
{
return l.x > r.x;
}
}
};
};
typedef vector<Block> Vblock;
int main()
{
int i = 1;
int n;
Vblock blocks;
vector<int> dp;
blocks.reserve(30*6);
dp.reserve(30*6);
while (cin >> n)
{
if (n == 0)
{
break;
}
blocks.resize(6*n);
int x, y, z;
for (Vblock::iterator iter = blocks.begin(); iter != blocks.end(); )
{
cin >> x >> y >> z;
iter->x = x; iter->y = y; iter->z = z;
iter++;
iter->x = x; iter->y = z; iter->z = y;
iter++;
iter->x = y; iter->y = x; iter->z = z;
iter++;
iter->x = y; iter->y = z; iter->z = x;
iter++;
iter->x = z; iter->y = x; iter->z = y;
iter++;
iter->x = z; iter->y = y; iter->z = x;
iter++;
}
sort(blocks.begin(), blocks.end(), Block::Pred());
dp.resize(6 * n);
dp[0] = blocks[0].z;
for (int j = 1; j < 6 * n; j++)
{
int q = 0;
//int mh = 0;
for (int k = 0; k < j; k++)
{
if (blocks[k].x > blocks[j].x && blocks[k].y > blocks[j].y)
{
q = max(q, dp[k]);
//mh = blocks[k].z;
}
}
dp[j] = q + blocks[j].z;
}
int ans = *max_element(dp.begin(), dp.end());
blocks.clear();
cout << "Case " << i++ << ": maximum height = " << ans << endl;
}
return 0;
}
|
#include "MyTruthAnalysis/Cutflow.h"
#include <iostream>
#include <iomanip>
using std::cout;
using std::setw;
using std::size_t;
using std::string;
using std::vector;
void Cutflow::addCut(const std::string &sName, const float &fWeights)
{
if (m_mapIndex.find(sName) != m_mapIndex.end())
{
m_vCutflow[m_mapIndex[sName]].second += fWeights;
}
else
{
m_vCutflow.push_back(std::make_pair(sName, fWeights));
m_mapIndex[sName] = m_vCutflow.size() - 1;
}
}
void Cutflow::print() const
{
cout << "Printing cutflow\n";
cout << "----------------\n";
size_t nLongestP2{2};
for (auto &p : m_vCutflow)
{
nLongestP2 = std::max(p.first.length() + 2, nLongestP2);
}
cout << std::left << setw(5) << "idx " << std::left << setw(nLongestP2)
<< "Name" << std::left << setw(10) << "SumW" << "Rel. Eff.\n";
for (size_t i = 0; i < m_vCutflow.size(); ++i)
{
cout << "(" << std::left << setw(2) << i + 1 << ") "
<< std::left << setw(nLongestP2) << m_vCutflow[i].first
<< std::left << setw(10) << m_vCutflow[i].second;
if (i > 0 && m_vCutflow[i].first.find("Count") == std::string::npos)
cout << m_vCutflow[i].second / m_vCutflow[i - 1].second << '\n';
else
cout << '\n';
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a=10;
printf("a is %d\n",a);
printf("a==10 is %d\n",a==10);
printf("a==20 is %d\n",a==20);
printf("a!=10 is %d\n",a!=10);
printf("a!=20 is %d\n",a!=20);
}
|
#include "daemon.h"
static char s_cfgFilename[PATH_MAX + 1];
static int s_updatePeriod;
static char s_dirToDelete[PATH_MAX + 1];
static void loadConfig()
{
FILE* cfgFile = fopen(s_cfgFilename, "r");
if (cfgFile == NULL)
{
syslog(LOG_ERR, "Failed to find configuration file (%s). Terminating daemon\n", s_cfgFilename);
closelog();
exit(EXIT_FAILURE);
}
if (fscanf(cfgFile, "%s %i", s_dirToDelete, &s_updatePeriod) != 2)
{
syslog(LOG_ERR, "Failed to read configuration file. Terminating daemon\n");
fclose(cfgFile);
closelog();
exit(EXIT_FAILURE);
}
syslog(LOG_NOTICE, "Configuration file read successfully\n");
fclose(cfgFile);
}
void reloadCfgFile(int signum)
{
syslog(LOG_NOTICE, "Received signal SIGHUP: reloading .cfg file\n");
loadConfig();
}
void stopDaemon(int signum)
{
syslog(LOG_NOTICE, "Received signal SIGTERM: terminating daemon\n");
closelog();
exit(EXIT_SUCCESS);
}
static void setSignalHandlers()
{
signal(SIGTERM, stopDaemon);
signal(SIGHUP, reloadCfgFile);
}
static void daemonMainLoop()
{
static int loopNum = 1;
syslog(LOG_NOTICE, "Doing loop #%i\n", loopNum++);
std::ostringstream shellCommand;
shellCommand << "#!/bin/bash \n";
shellCommand << "dir=" << s_dirToDelete << " \n";
shellCommand << "if test -z $(find $dir -type f -name dont.erase) ; then \n";
shellCommand << " rm -rf $dir/*\n";
shellCommand << "fi";
system(shellCommand.str().c_str());
syslog(LOG_NOTICE, "Loop ended\n");
sleep(s_updatePeriod);
}
void startDaemon(char* cfgFilename)
{
pid_t pid;
/* Fork off the parent process */
pid = fork();
/* An error occurred */
if (pid < 0)
{
exit(EXIT_FAILURE);
}
/* Success: Let the parent terminate */
if (pid > 0)
{
exit(EXIT_SUCCESS);
}
/* On success: The child process becomes session leader */
if (setsid() < 0)
{
exit(EXIT_FAILURE);
}
strcpy(s_cfgFilename, cfgFilename);
loadConfig();
realpath(cfgFilename, s_cfgFilename);
/* Catch, ignore and handle signals */
setSignalHandlers();
/* Fork off for the second time*/
pid = fork();
/* An error occurred */
if (pid < 0)
{
exit(EXIT_FAILURE);
}
/* Success: Let the parent terminate */
if (pid > 0)
{
exit(EXIT_SUCCESS);
}
/* Set new file permissions */
umask(0);
/* Change the working directory to the root directory */
/* or another appropriated directory */
chdir("/");
/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
/* Open the log file */
openlog (DAEMON_NAME, LOG_PID, LOG_DAEMON);
syslog (LOG_NOTICE, "Daemon main loop has been started\n");
for (;;)
{
daemonMainLoop();
}
}
|
#ifndef __GRAPH_HPP__
#define __GRAPH_HPP__
#include <list>
#include <utility>
#include <vector>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/topological_sort.hpp>
#include <boost/graph/bellman_ford_shortest_paths.hpp>
#include <boost/graph/graphviz.hpp>
#define MON_Internal_UnusedStringify(macro_arg_string_literal) #macro_arg_string_literal
#define MONUnusedParameter(macro_arg_parameter) _Pragma(MON_Internal_UnusedStringify(unused(macro_arg_parameter)))
//
// boost adjacency_list type
// adjacency_list<OutEdgeList, VertexList, Directed,
// VertexProperties, EdgeProperties,
// GraphProperites, EdgeList>
//
// typedef boost::property<boost::edge_weight_t, float> EdgeWeightProperty;
struct EdgeWeightProperty {
EdgeWeightProperty() : weight(0) {}
EdgeWeightProperty(float w) : weight(w) {}
float weight;
};
using graph_t = boost::adjacency_list<boost::listS,
boost::vecS,
boost::directedS,
boost::no_property,
EdgeWeightProperty>;
using edge_descriptor = boost::graph_traits<graph_t>::edge_descriptor;
using edge_iterator = boost::graph_traits<graph_t>::edge_iterator;
class PartitionGraph {
public:
PartitionGraph(int n,
int T,
std::vector<float> a,
std::vector<float> b
) :
n_{n},
T_{T},
a_{a},
b_{b},
per_level_{n-T+1},
priority_sortind_{std::vector<int>(T_)},
optimalweight_{0.},
subsets_{std::vector<std::vector<int>>(T_)}
{ _init(); }
PartitionGraph(int n,
int T,
float *a,
float *b
):
n_{n},
T_{T},
per_level_{n-T+1},
priority_sortind_{std::vector<int>(T_)},
optimalweight_{0.},
subsets_{std::vector<std::vector<int>>(T_)}
{
a_.assign(a, a+n);
b_.assign(b, b+n);
_init();
}
void create();
void optimize();
void _init() { create(); optimize(); }
std::list<std::pair<int, int>> get_optimal_path() const;
std::vector<int> get_optimal_path_extern() const;
std::vector<std::vector<int>> get_optimal_subsets_extern() const;
float get_optimal_weight_extern() const;
void write_dot();
private:
int n_;
int T_;
std::vector<float> a_;
std::vector<float> b_;
int per_level_;
std::vector<int> priority_sortind_;
std::list<std::pair<int, int>> optimalpath_;
std::list<int> optimalnodepath_;
float optimalweight_;
std::list<int> optimaledgeweights_;
std::vector<std::vector<int>> subsets_;
graph_t G_;
inline int node_to_int(int,int);
inline std::pair<int, int> int_to_node(int);
void sort_by_priority(std::vector<float>&, std::vector<float>&);
float compute_weight(int, int);
float compute_weight(int, int, std::vector<float>&);
void add_edge_and_weight(int, int, std::vector<float>&&);
};
#endif
|
// Created on: 2004-11-23
// Created by: Pavel TELKOV
// Copyright (c) 2004-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// The original implementation Copyright: (C) RINA S.p.A
#ifndef TObj_Application_HeaderFile
#define TObj_Application_HeaderFile
#include <TDocStd_Application.hxx>
#include <TObj_Common.hxx>
#include <Message_Gravity.hxx>
#include <Message_Messenger.hxx>
//!
//! This is a base class for OCAF based TObj models
//! with declared virtual methods
//!
class TObj_Application : public TDocStd_Application
{
public:
//! Returns static instance of the application
Standard_EXPORT static Handle(TObj_Application) GetInstance();
//! Returns reference to associated messenger handle
Handle(Message_Messenger) &Messenger() { return myMessenger; }
public:
/**
* Load/Save support
*/
//! Saving the OCAF document to a file
Standard_EXPORT virtual Standard_Boolean SaveDocument
(const Handle(TDocStd_Document)& theSourceDoc,
const TCollection_ExtendedString& theTargetFile);
//! Saving the OCAF document to a stream
Standard_EXPORT virtual Standard_Boolean SaveDocument
(const Handle(TDocStd_Document)& theSourceDoc,
Standard_OStream& theOStream);
//! Loading the OCAF document from a file
Standard_EXPORT virtual Standard_Boolean LoadDocument
(const TCollection_ExtendedString& theSourceFile,
Handle(TDocStd_Document)& theTargetDoc);
//! Loading the OCAF document from a stream
Standard_EXPORT virtual Standard_Boolean LoadDocument
(Standard_IStream& theIStream,
Handle(TDocStd_Document)& theTargetDoc);
//! Create the OCAF document from scratch
virtual Standard_EXPORT Standard_Boolean CreateNewDocument
(Handle(TDocStd_Document)& theDoc,
const TCollection_ExtendedString& theFormat);
//! Signal error during Load or Save
//! Default imiplementation is empty
virtual Standard_EXPORT void ErrorMessage
(const TCollection_ExtendedString &theMsg,
const Message_Gravity theLevel);
//! Signal error during Load or Save
//! Default imiplementation invoke previous declaration with 0
virtual void ErrorMessage
(const TCollection_ExtendedString &theMsg)
{ ErrorMessage( theMsg, Message_Alarm ); }
//! Sets the verbose flag, meaning that load/save models should show
//! CPU and elapsed times
void SetVerbose (const Standard_Boolean isVerbose)
{ myIsVerbose = isVerbose; }
//! Returns the verbose flag
Standard_Boolean IsVerbose () const
{ return myIsVerbose; }
//! Dumps the content of me into the stream
Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
public:
/**
* Redefined OCAF methods
*/
//! Return name of resource (i.e. "TObj")
virtual Standard_EXPORT Standard_CString ResourcesName() Standard_OVERRIDE;
protected:
/**
* Constructor
*/
//! Constructor is protected. Use method GetInstance() method to obtain
//! the static instance of the object (or derive your own application)
Standard_EXPORT TObj_Application();
//! Sets an error occurred on storage of a document.
void SetError (const PCDM_StoreStatus theStatus, const TCollection_ExtendedString& theInfo);
//! Sets an error occurred on reading of a document.
void SetError (const PCDM_ReaderStatus theStatus, const TCollection_ExtendedString& theInfo);
private:
/**
* Fields
*/
Standard_Boolean myIsError; //!< error flag
Standard_Boolean myIsVerbose; //!< verbose flag
Handle(Message_Messenger) myMessenger; //!< messenger
public:
//! CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(TObj_Application,TDocStd_Application)
};
//! Define handle class
DEFINE_STANDARD_HANDLE(TObj_Application,TDocStd_Application)
#endif
|
#include "CWorld.h"
CPlayerInfo *CWorld::Players = (CPlayerInfo *)0xB7CD98;
int8_t& CWorld::PlayerInFocus = *(int8_t *)0xB7CD74;
CEntity *&CWorld::pIgnoreEntity = *(CEntity **)0xB7CD68;
Bool CWorld::ProcessLineOfSight(CVector const& origin, CVector const& target, CColPoint &colPoint,
CEntity *&colEntity, bool buildings, bool vehicles, bool peds,
bool objects, bool dummies, bool seeThrough, bool cameraObjects,
bool shootThrough)
{
return ((Bool (__cdecl *)(CVector const&, CVector const&, CColPoint &, CEntity *&, bool, bool, bool,
bool, bool, bool, bool, bool))0x56BA00)(origin, target, colPoint, colEntity, buildings,
vehicles, peds, objects, dummies, seeThrough, cameraObjects, shootThrough);
}
float CWorld::FindGroundZForCoord(float x, float y)
{
return ((float (__cdecl *)(float, float))0x569660)(x, y);
}
|
#ifndef Glowing_h
#define Glowing_h
#include "Animation.h"
class Glowing : public Animation {
public:
Glowing(void);
virtual void loop(variables_t *vars);
virtual void reset(variables_t *vars);
private:
};
#endif
|
//
// Created by Brady Bodily on 2/3/17.
//
#include <string>
#include <iostream>
#include "PurchaseSale.hpp"
PurchaseSale::PurchaseSale(std::string symbol, int quantity, int purchaseTime,
int purchasePrice, int purchaseFee, int saleTime, int salePrice, int saleFee) :
m_symbol(symbol),
m_quantity(quantity),
m_purchaseTime(purchaseTime),
m_purchasePrice(purchasePrice),
m_purchaseFee(purchaseFee),
m_saleTime(saleTime),
m_salePrice(salePrice),
m_saleFee(saleFee)
{}
double PurchaseSale::computePL() {
double inv = (m_quantity * m_purchasePrice) + m_purchaseFee + m_saleFee;
return (m_quantity * m_salePrice) - inv;
}
std::string PurchaseSale::getSymbol() {
return m_symbol;
}
int PurchaseSale::getPTime() {
return m_purchaseTime;
}
int PurchaseSale::getSTime() {
return m_saleTime;
}
|
#include <conio.h>
#include <stdio.h>
void main () {
clrscr();
int guests, chairs, fact=1;
printf("Enter number of guests: ");
scanf("%d",&guests);
printf("Enter number of chairs: ");
scanf("%d",&chairs);
int n = guests-chairs;
fact=guests;
for(int i=guests-1; i>n; i--)
fact = (fact*i);
printf("\n\nThe possible arrangement of %d guests in %d chairs is %d",guests,chairs,fact);
getch();
}
|
// Created on: 1993-01-11
// Created by: CKY / Contract Toubro-Larsen (TCD)
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IGESGraph_HeaderFile
#define _IGESGraph_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class IGESGraph_Protocol;
//! This package contains the group of classes necessary
//! to define Graphic data among Structure Entities.
//! (e.g., Fonts, Colors, Screen management ...)
class IGESGraph
{
public:
DEFINE_STANDARD_ALLOC
//! Prepares dynamic data (Protocol, Modules) for this package
Standard_EXPORT static void Init();
//! Returns the Protocol for this Package
Standard_EXPORT static Handle(IGESGraph_Protocol) Protocol();
};
#endif // _IGESGraph_HeaderFile
|
//
// Cat.hpp
// MixingCppObjC
//
// Created by Miralem Cebic on 27.07.17.
// Copyright © 2017 Miralem Cebic. All rights reserved.
//
#ifndef Cat_hpp
#define Cat_hpp
#include <stdio.h>
#include <iostream>
class Cat
{
public:
Cat(int initialAge);
Cat(const Cat& copy_from);
~Cat();
int GetAge() const;
void SetAge(int age);
void Meow();
private:
int itsAge;
char * string;
};
#endif /* Cat_hpp */
|
#pragma once
#include <vector>
#include "rectangularvectors.h"
namespace WinTetris
{
class Grid
{
public:
const int width, height;
std::vector<std::vector<bool>> occupied;
Grid(int w, int h);
void FillCell(int x, int y);
void UnFillCell(int x, int y);
bool isFinish(Grid *block);
std::vector<std::vector<bool>> Union(std::vector<std::vector<bool>> &c1, std::vector<std::vector<bool>> &c2);
bool isRow(int index, bool predicate);
bool isColumn(int index, bool predicate);
void ShiftToLeft();
void ShiftToRight();
void ShiftToDown(int index);
};
}
|
#include <iostream>
#include <thread>
int glob = 1337;
void foo()
{
std::cout << "foo done " << glob << std::endl;
}
void bar()
{
std::cout << "bar done " << glob << std::endl;
}
int main()
{
auto fooThread = std::thread(foo); // startuje dany watek
auto barThread = std::thread(bar); // startuje dany watek
fooThread.join(); // blokuje az do zakonczenia danego watku
barThread.join(); // blokuje az do zakonczenia danego watku
std::cout << "main done" << std::endl;
return 0;
}
|
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
class Solution {
public:
vector<string> res;
vector<string> addOperators(string num, int target) {
//基本思想：递归回溯，暴力遍历所有的可能性，时间复杂度O(4^N)
string s="";
Recursion(num,target,0,0,1,s);
return res;
}
void Recursion(string& num,int target,int index,long cur,long prenum,string& s)
{
//index表示当前遍历num的下标，cur表示当前计算结果，s表示加上运算符的字符串，prenum表示上一步的操作数
if(index==num.size())
{
if(cur==target)
res.push_back(s);
return;
}
string temp;
//以当前下标index为起点，遍历下一个操作数的所有可能情况
for (int i = index; i < num.size(); i++)
{
string val = num.substr(index, i - index + 1);
long n = stol(val); //val转化为数字
//第一个数字，不需要加符号
if (index == 0) {
temp=s+val;
Recursion(num,target,i+1,n,n,temp);
} else {
// +
temp=s+"+"+val;
Recursion(num,target,i+1,cur+n,n,temp);
// -
temp=s+"-"+val;
Recursion(num,target,i+1,cur-n,-n,temp);
// *，乘法分配率高于加减，所以将上一步的操作数减去，重新计算
temp=s+"*"+val;
Recursion(num,target,i+1,cur-prenum+prenum*n,prenum*n,temp);
}
//以0开头的数字只能是0自己这一种情况，其他情况不允许
if (val=="0") return;
}
return;
}
};
int main()
{
Solution solute;
string num="232";
int target=8;
vector<string> res=solute.addOperators(num,target);
for_each(res.begin(),res.end(),[](string s){cout<<s<<endl;});
return 0;
}
|
#ifndef VnaCalibrate_H
#define VnaCalibrate_H
// RsaToolbox
#include "Definitions.h"
#include "NameLabel.h"
#include "Connector.h"
// Qt
#include <QObject>
#include <QScopedPointer>
namespace RsaToolbox {
class Vna;
class VnaChannel;
class VnaCalibrate : public QObject
{
Q_OBJECT
public:
enum CalType {
AdapterRemoval,
ReflectionNormOpen,
ReflectionNormShort,
Osm,
TransmitNormForward,
TransmitNormReverse,
TransmitNormBothDirections,
OnePathTwoPorts,
Tosm,
Uosm,
Trl,
NistTrl, // ZVA Family Only
Tom,
Tsm,
Trm,
Tna,
// + Power Cal
// (ZNB Family Only)
AdapterRemoval_SMARTerCal,
Tosm_SMARTerCal,
Uosm_SMARTerCal,
Trl_SMARTerCal,
Tom_SMARTerCal,
Tsm_SMARTerCal,
Trm_SMARTerCal,
Tna_SMARTerCal
};
explicit VnaCalibrate(QObject *parent = 0);
VnaCalibrate(const VnaCalibrate &other);
VnaCalibrate(Vna *vna, QObject *parent = 0);
VnaCalibrate(Vna *vna, VnaChannel *channel, QObject *parent = 0);
VnaCalibrate(Vna *vna, uint channelIndex, QObject *parent = 0);
~VnaCalibrate();
bool isRawDataKept();
void keepRawData(bool isKept = true);
Connector connector(uint port);
QVector<Connector> connectors();
void setConnector(uint port, Connector connector);
void setConnectors(Connector connector);
void selectKit(NameLabel nameLabel);
void selectKit(QString name, QString label = "");
NameLabel selectedKit(Connector type);
void start(QString calibrationName, CalType type, QVector<uint> ports);
void measureOpen(uint port);
void measureShort(uint port);
void measureMatch(uint port);
void measureOffsetShort1(uint port);
void measureOffsetShort2(uint port);
void measureOffsetShort3(uint port);
void measureThru(uint port1, uint port2);
void apply();
bool autoCalibrate(QVector<uint> ports, QString calId="", QString characterization="");
void operator=(const VnaCalibrate &other);
private:
Vna *_vna;
QScopedPointer<Vna> placeholder;
bool _isChannelSpecific;
QScopedPointer<VnaChannel> _channel;
uint _channelIndex;
uint timeout_ms();
static uint _timeout_ms;
bool isFullyInitialized() const;
bool isMissingZvaCommand();
void selectKit(NameLabel nameLabel, Connector type);
void selectKit(QString name, QString label, Connector type);
void selectKit(QString name, QString label, QString connectorType);
void defineCalibration(QString calibrationName, CalType type, QVector<uint> ports);
void selectChannels();
};
} // RsaToolbox
Q_DECLARE_METATYPE(RsaToolbox::VnaCalibrate::CalType)
#endif // VnaCalibrate_H
|
#include "entity.hpp"
EntityGUI::EntityGUI()
: m_Label(Label())
, m_DoubleSpinBox(DoubleSpinBox())
, m_LCDNumber(LCDNumber())
, m_Layout(Layout())
, m_Frame(Frame())
, m_ComboBox_Species(new QComboBox)
, m_CheckBox_Magical(new QCheckBox)
{
initGUI();
}
EntityGUI::Label::Label()
: Weight(new QLabel)
, Height(new QLabel)
, Health(new QLabel)
, Mana(new QLabel)
{}
EntityGUI::DoubleSpinBox::DoubleSpinBox()
: Weight(new QDoubleSpinBox)
, Height(new QDoubleSpinBox)
{}
EntityGUI::LCDNumber::LCDNumber()
: Health(new QLCDNumber)
, Mana(new QLCDNumber)
{}
EntityGUI::Layout::Layout()
: hBox_Weight(new QHBoxLayout)
, hBox_Height(new QHBoxLayout)
, hBox_Health(new QHBoxLayout)
, hBox_Mana(new QHBoxLayout)
, hBox_Entity(new QHBoxLayout)
, vBox_HealthAndMana(new QVBoxLayout)
{}
EntityGUI::Frame::Frame()
: Weight(new QFrame)
, Height(new QFrame)
, Health(new QFrame)
, Mana(new QFrame)
, HealthAndMana(new QFrame)
, Entity(new QFrame)
{}
void EntityGUI::initLabel() {
setLabel(m_Label.Mana, "Manaenergie:", 140, 25);
setLabel(m_Label.Health, "Lebensenergie:", 140, 25);
setLabel(m_Label.Height, "Größe:", 80, 25);
setLabel(m_Label.Weight, "Gewicht:", 80, 25);
}
void EntityGUI::initDoubleSpinBox() {
m_DoubleSpinBox.Height->setDecimals(2);
setFont(m_DoubleSpinBox.Height, 12);
m_DoubleSpinBox.Weight->setDecimals(2);
setFont(m_DoubleSpinBox.Weight, 12);
}
void EntityGUI::initLCDNumber() {
m_LCDNumber.Mana->setDigitCount(7);
m_LCDNumber.Health->setDigitCount(7);
}
void EntityGUI::initLayout() {
m_Layout.hBox_Weight->addWidget(m_Label.Weight);
m_Layout.hBox_Weight->addWidget(m_DoubleSpinBox.Weight);
m_Layout.hBox_Height->addWidget(m_Label.Height);
m_Layout.hBox_Height->addWidget(m_DoubleSpinBox.Height);
m_Layout.hBox_Health->addWidget(m_Label.Health);
m_Layout.hBox_Health->addWidget(m_LCDNumber.Health);
m_Layout.hBox_Mana->addWidget(m_Label.Mana);
m_Layout.hBox_Mana->addWidget(m_LCDNumber.Mana);
m_Layout.vBox_HealthAndMana->addWidget(m_Frame.Health);
m_Layout.vBox_HealthAndMana->addWidget(m_Frame.Mana);
m_Layout.hBox_Entity->addWidget(m_Frame.Weight);
m_Layout.hBox_Entity->addWidget(m_Frame.Height);
m_Layout.hBox_Entity->addWidget(m_ComboBox_Species);
m_Layout.hBox_Entity->addWidget(m_Frame.HealthAndMana);
m_Layout.hBox_Entity->addWidget(m_CheckBox_Magical);
}
void EntityGUI::initFrame() {
m_Frame.Weight->setLayout(m_Layout.hBox_Weight);
m_Frame.Height->setLayout(m_Layout.hBox_Height);
m_Frame.Health->setLayout(m_Layout.hBox_Health);
m_Frame.Mana->setLayout(m_Layout.hBox_Mana);
m_Frame.HealthAndMana->setLayout(m_Layout.vBox_HealthAndMana);
m_Frame.Entity->setLayout(m_Layout.hBox_Entity);
}
void EntityGUI::initGUI() {
initLabel();
initDoubleSpinBox();
initLCDNumber();
setCheckbox(m_CheckBox_Magical);
setComboBox(m_ComboBox_Species, {"TODO Spezies"});
initLayout();
initFrame();
}
void EntityGUI::setLabel(QLabel* obj, QString text, int width, int height) {
obj->setText(text);
setFont(obj, 16);
obj->setAlignment(Qt::AlignLeft);
obj->setFixedSize(QSize(width, height));
}
void EntityGUI::setCheckbox(QCheckBox* obj) {
obj->setText("Magisch");
setFont(obj, 12);
}
void EntityGUI::setComboBox(QComboBox* obj, std::vector<QString> items) {
obj->clear();
for (QString var : items) {
obj->addItem(var);
}
setFont(obj, 12);
obj->setFixedSize(QSize(300, 30));
}
void EntityGUI::setFont(QWidget *obj, int size) {
obj->setFont(QFont("Times New Roman", size, QFont::Bold));
}
QFrame* EntityGUI::getFrameEntity() {
return m_Frame.Entity;
}
|
#include <signal.h>
#include <unistd.h>
#include <iostream>
using namespace std;
int received_signum = 0;
void signalHandler(int signum)
{
received_signum = signum;
}
void registerSignals()
{
signal(SIGINT, signalHandler);
signal(SIGUSR1, signalHandler);
signal(SIGUSR2, signalHandler);
}
int listenForSignals(int execution_mode)
{
cout << "This process ID is: " << getpid() << "\n";
cout << "Listening for signals SIGINT, SIGUSR1 and SIGUSR2...\n";
while (1) {
// Move program to wait state in case the user
// has selected blocking wait mode.
if (execution_mode == 2) {
pause();
}
while (received_signum != 0) {
if (received_signum == SIGINT) {
cout << "Received signal: " << received_signum << "\n";
cout << "Stopping execution...\n";
return 0;
} else {
cout << "Received signal: " << received_signum << "\n";
received_signum = 0;
}
}
}
}
int main(void) {
int execution_mode;
cout << "Pick an execution mode:\n";
cout << " 1 - Busy wait;\n";
cout << " 2 - Blocking wait;\n";
cin >> execution_mode;
registerSignals();
return listenForSignals(execution_mode);
}
|
#pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <iterator>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <unordered_map>
#include <unordered_set>
using namespace std;
void abhisheknaiidu()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int main(int argc, char* argv[]) {
abhisheknaiidu();
string path = "/home//foo/";
string ans = "";
int n = path.size();
if(path[n-1] == '/') path.erase(path.begin() + n-1);
int m = path.size();
ans += path[0];
for(int i=1; i<m;i++) {
if((path[i-1] == '/') && (path[i] == '/')) continue;
// cout << i << endl;
ans += path[i];
if(path[i] == '.') ans.clear();
}
cout << ans << endl;
return 0;
}
|
//==================================================================================================
// Name : DebugUtil.h
// Author : Ken Cheng
// Copyright : This work is licensed under the Creative Commons
// Attribution-NonCommercial-ShareAlike 4.0 International License. To view a copy of this
// license, visit http://creativecommons.org/licenses/by-nc-sa/4.0/.
// Description :
//==================================================================================================
#ifndef DEBUGUTIL_H_
#define DEBUGUTIL_H_
#include "../Configuration.h"
#include <map>
#include <vector>
#include <set>
using namespace std;
namespace LabRetriever {
template <class A>
void debug(const A& a);
template <class A, class B>
void debugToken(const map<A, B>& m);
template <class A>
void debugToken(const vector<A>& v);
template <class A>
void debugToken(const set<A>& s);
void debugToken(const AlleleProfile& a);
void debugToken(const ReplicateData& r);
void debugToken(const Configuration& c);
// Default.
template <class A>
void debugToken(const A& a);
}
#endif /* DEBUGUTIL_H_ */
|
/**
* Copyright (c) 2021, Timothy Stack
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Timothy Stack nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "base/string_util.hh"
#include "base/strnatcmp.h"
#include "config.h"
#include "doctest/doctest.h"
TEST_CASE("endswith")
{
std::string hw("hello");
CHECK(endswith(hw, "f") == false);
CHECK(endswith(hw, "lo") == true);
}
TEST_CASE("truncate_to")
{
const std::string orig = "0123456789abcdefghijklmnopqrstuvwxyz";
std::string str;
truncate_to(str, 10);
CHECK(str == "");
str = "abc";
truncate_to(str, 10);
CHECK(str == "abc");
str = orig;
truncate_to(str, 10);
CHECK(str == "01234\u22efwxyz");
str = orig;
truncate_to(str, 1);
CHECK(str == "\u22ef");
str = orig;
truncate_to(str, 2);
CHECK(str == "\u22ef");
str = orig;
truncate_to(str, 3);
CHECK(str == "0\u22efz");
str = orig;
truncate_to(str, 4);
CHECK(str == "01\u22efz");
str = orig;
truncate_to(str, 5);
CHECK(str == "01\u22efyz");
}
TEST_CASE("strnatcmp")
{
{
constexpr const char* n1 = "010";
constexpr const char* n2 = "020";
CHECK(strnatcmp(strlen(n1), n1, strlen(n2), n2) < 0);
}
{
constexpr const char* n1 = "2";
constexpr const char* n2 = "10";
CHECK(strnatcmp(strlen(n1), n1, strlen(n2), n2) < 0);
}
}
|
//: C10:MyLib.cpp
// Kod zrodlowy pochodzacy z ksiazki
// "Thinking in C++. Edycja polska"
// (c) Bruce Eckel 2000
// Informacje o prawie autorskim znajduja sie w pliku Copyright.txt
namespace MyLib {
// Deklaracje
}
int main() {} ///:~
|
//$$---- Form CPP ----
//---------------------------------------------------------------------------
#include <vcl.h>
#include <mmsystem.h>
#include <stdio.h>
#include <fstream.h>
#pragma hdrstop
#include "TimeCourses.h"
#include "PredStart.h"
#include "ExperimentNotes.h"
#include "BuildProtocol.h"
#include "Gistograms.h"
#include "CalcParams.h"
#include "RenamOverr.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "cspin"
#pragma resource "*.dfm"
TGraphs *Graphs;
const short eheadSBlock = 12,//количество блоков в структуре ehead
dataInHead = 5,//количество блоков, данные которых есть только в заголовке
pureData = eheadSBlock - dataInHead;//количество блоков с экспериментальными данными
blockbyte ehead[eheadSBlock];//задаём структуру файлов с данными
trac *gSignals;//структура для сигналов с их параметрами
__int32 *devExpParams_int,//параметры устройства и эксперимента (__int32)
gPreTime,//начало пресин. ответа (микросекунды)
gPostTime,//начало постсин. ответа (микросекунды)
gTimeBgn;//начало рисования (микросекунды)
short experimentType,//тип эксперимента (глобальный вариант)
gPorog;//порог (отсчёты)
float *devExpParams_float;//параметры устройства и эксперимента (float)
bool mask[9],//маска "открытости" графиков для режима равёртывания
_isfull;//развёрнут ли какой-либо график
//---------------------------------------------------------------------------
__fastcall TGraphs::TGraphs(TComponent* Owner)
: TForm(Owner)
{
short i;
//--------------------------------------------------------------
//--- константная часть файл. Новый формат *.pra ---
i = 0;
ehead[i].nob = "название файла, версия программы, время создания и время последнего редактирования файла";
ehead[i].byteInHead = 0;
ehead[i].byteInFile = 0;
ehead[i].szDataType = sizeof(char);//данные только в заголовке
ehead[i].szInHDataType = ehead[i].szDataType;
ehead[i].numOfElements = 64;
//--------------------------------------------------------------
i++;//1
ehead[i].nob = "размер блока (в байтах) с информацией об эксперименте, вводимой пользователем";//
ehead[i].szDataType = sizeof(__int32);
ehead[i].numOfElements = 1;
//--------------------------------------------------------------
i++;//2
ehead[i].nob = "__int32 параметры сбора данных (ADCParametersDMA а) + тип эксперимента + параметры эксперимента";
ehead[i].szDataType = sizeof(__int32);
ehead[i].numOfElements = 15;
//--------------------------------------------------------------
i++;//3
ehead[i].nob = "float параметры сбора данных (ADCParametersDMA а) + тип эксперимента + параметры эксперимента";
ehead[i].szDataType = sizeof(float);
ehead[i].numOfElements = 6;
//--------------------------------------------------------------
i++;//4
ehead[i].nob = "число записанных сигналов";
ehead[i].szDataType = sizeof(__int32);
ehead[i].numOfElements = 1;
//--------------------------------------------------------------
//--- информация о размещении данных измерения ---
//параметры byteInFile и numOfElements для следующих блоков рассчитываются при сохранении данных
i++;//5
//(1)
ehead[i].nob = "номер первого байта блока с развёртками сигналов и значениями параметров (все каналы)";//(1)
ehead[i].szInHDataType = sizeof(unsigned long);
ehead[i].szDataType = sizeof(char);//условный размер
//--------------------------------------------------------------
i++;//6
ehead[i].nob = "резерв (номер первого байта какого-нибудь блока)";
ehead[i].szInHDataType = sizeof(unsigned long);
ehead[i].szDataType = sizeof(char);//условный размер
//--------------------------------------------------------------
i++;//7
ehead[i].nob = "резерв (номер первого байта какого-нибудь блока)";
ehead[i].szInHDataType = sizeof(unsigned long);
ehead[i].szDataType = sizeof(char);//условный размер
//--------------------------------------------------------------
i++;//8
ehead[i].nob = "номер первого байта блока с информацией об эксперименте, вводимой пользователем";
ehead[i].szInHDataType = sizeof(unsigned long);
ehead[i].szDataType = sizeof(char);//размер
//--------------------------------------------------------------
i++;//9
ehead[i].nob = "номер первого байта блока с номерами сигналов, к которым привязаны заметки";//
ehead[i].szInHDataType = sizeof(unsigned long);
ehead[i].szDataType = sizeof(__int32);//размер
//--------------------------------------------------------------
i++;//10
ehead[i].nob = "номер первого байта блока с видимостями меток на каналах";
ehead[i].szInHDataType = sizeof(unsigned long);
ehead[i].szDataType = sizeof(bool);//размер
//--------------------------------------------------------------
i++;//11
ehead[i].nob = "резерв (номер первого байта какого-нибудь блока)";
ehead[i].szInHDataType = sizeof(unsigned long);
ehead[i].szDataType = sizeof(char);//условный размер
//====================================================================
//рассчитаем размеры в байтах
for (i = 1; i < eheadSBlock; i++)
if (i < dataInHead)//данные, располагаемые только в заголовке
{
ehead[i].szInHDataType = ehead[i].szDataType;
ehead[i].byteInHead = ehead[i - 1].byteInHead + (ehead[i - 1].numOfElements * ehead[i - 1].szInHDataType);
ehead[i].byteInFile = ehead[i].byteInHead;
}
else//все остальные
ehead[i].byteInHead = ehead[i - 1].byteInHead + (1 * ehead[i - 1].szInHDataType);//1 элемента
//прописываем названия колонок таблицы с параметрами сигналов
pValues->ColCount = 5;//10 + maxChannels;//18;//количество колонок в таблице по количеству параметров
pValues->Cells[0][0] = "№сигнала";
pValues->Cells[1][0] = "время, с";
pValues->Cells[2][0] = "ампл, мВ";//амплитуда основная - постсинаптическая (после красной линии)
pValues->Cells[3][0] = "rise, мкс";//время нарастания (микросекунды)
pValues->Cells[4][0] = "спад, мкс";//время спада (микросекунды)
pValues->ColWidths[0] = (pValues->Cells[0][0].Length()) * 7;//первые две колонки всегда видны
pValues->ColWidths[1] = (pValues->Cells[1][0].Length()) * 7;//первые две колонки всегда видны
//заполняем массив копий указателей на графики (чарты)
allCharts[0] = SignalTrack;//текущий (средний) сигнал
allCharts[1] = AmplInT;//главная амплитуда
allCharts[2] = RiseTInT;//время нарастания
allCharts[3] = FallTInT;//время спада
allCharts[4] = NaAmplInT;//амплитуда Na тока
allCharts[5] = NaDurInT;//длительность натриевого тока
allCharts[6] = KAmplInT;//амплитуда K тока
allCharts[7] = SynDelInT;//синаптическая задержка
allCharts[8] = SynTrnsInT;//время синаптического проведения
AmplInT->Canvas->Font->Name = "Arial";//определяем стиль надписей (заметок по ходу эксперимента)
gSignals = NULL;//структура для сигналов с их параметрами
//Graphs->"чарты с графиками"->Tag - номер элемента в массиве Graphs->allCharts
}
//---------------------------------------------------------------------------
bool TGraphs::SaveExpDataToFile(short expType, trac *signals_loc, __int32 numOfSignal, bool saveType)
{
//сохранение в новом формате (новая структура фалов *.pra)
/*
expType - тип эксперимента
signals_loc - локальная ссылка на структуру с сигналами
numOfSignal - количество собранных сигналов
saveType - тип сохранения (true = сохранение только-что проведённого эксперимента)
*/
void *refToWrite[eheadSBlock];//массив ссылок на блоки записываемых данных
unsigned long bytesCounter,//счётчик байтов; используется при задании структуры ehead
c,
m_nWritten,//число записанных байт
totWrit;//всего записано байт
__int32 i, j, g,
*sigsWithMark,//номера сигналов, к которым привязаны метки
fullSigLen,//полная длина записи на всех каналах (отсчёты)
dbN;//номер блока данных (data block number)
HANDLE hFile;//хэндл файла, в который сохраняются данные
TDateTime CurrentDateTime;//текущие дата и время
AnsiString progDate,//информация о программе и дате создания файла
userText,//информация об эксперименте от пользователяэ
versName;//имя программы, версия
float frstSignAppear;//время возникновения первого сигнала (в сохраняемом сеансе записи)
bool *markerVsblt;//видимость меток на каналах
if (expType < 5)
experimentType = expType;//копируем тип эксперимента в глобальную переменную
else//if expType == 5 (т.е. спонтанные сигналы в режиме №4)
experimentType = 1;
if (saveType)//сохранение только-что проведённого эксперимента
{
SigNumUpDwn->Max = numOfSignal;//задаём пределы изменения номеров сигналов (оставшихся после редактирования)
gSignals = signals_loc;//копируем разом всю информацию о сигналах
signals_loc = NULL;//тут же обнуляем локальную ссылку
gRF[0] = 0;//первый отображаемый канал
gRF[1] = 1;//последний отображаемый канал (отображаем какбы один, первый, канал)
ChannNumb[0]->Checked = true;//в начале выбранным является нулевой канал
gInd = new __int32[numOfSignal];//создаём массив индексов
for (i = 0; i < numOfSignal; i++)
gInd[i] = i;//заполняем массив индексов
//рассчитаем параметры
gPreTime = StrToInt(PStart->PreTime->Text);//ПРЕ-время в микросекундах
gPostTime = StrToInt(PStart->PostTime->Text);//ПОСТ-время в микросекундах
gPorog = short((float)StrToInt(PStart->Porog->Text) / sampl2mV);//пороговое напряжение (отсчёты)
//определяем начальный индекс для рисования
gTimeBgn = 0;
if (experimentType == 2)
gTimeBgn = gPostTime;
else if (experimentType == 3)
gTimeBgn = gPreTime;
}
//--------------------------------------------
//название файла, версия программы, время создания и время последнего редактирования файла
CurrentDateTime = Now();//текущие дата и время
versName = "ElphAcqu v";//версия программ
versName += progVer;//версия программ
if (saveType)//сохранение только-что проведённого эксперимента
{
progDate = versName;
progDate += "\r\nmade";
progDate += CurrentDateTime.DateTimeString().c_str();//19 символов
progDate += "\r\nedit";
progDate += CurrentDateTime.DateTimeString().c_str();//19 символов
}
else //сохранение отредактированного файла
{
progDate = ExpNotes->pIDateString;//редактируем запись о датах создания и изменения файла
j = progDate.AnsiPos("\r\nmade");//пытаемся найти другую метку
if (j > 0)//если метка наидена
{
progDate.Delete(j + 6 + 19, progDate.Length());//удаляем дату изменения
progDate.Delete(1, j - 1);//удаляем начальную часть записи
progDate.Insert(versName, 1);
}
else//если метки нет "made"
{
progDate = versName;
progDate += "\r\nmade";
progDate += CurrentDateTime.DateTimeString().c_str();//19 символов
}
progDate += "\r\nedit";
progDate += CurrentDateTime.DateTimeString().c_str();//19 символов
}
//====================================================
//информация о программе и дате создания данного файла
g = ehead[0].numOfElements - progDate.Length();
if (g < 0)//неправильная длина строки
progDate.SetLength(ehead[0].numOfElements);
else if (g > 0)
progDate += AnsiString::StringOfChar('_', g);
ExpNotes->pIDateString = progDate;//переписываем информацию о файле
userText = ExpNotes->usersNotes->Lines->Text;//информация об эксперименте (вводит пользователь)
if ((ExpNotes->addUMark->Tag > 0) && (expType != 5))//в userText вставляем и заметки по ходу эксперимента
{
userText += "\n\n\r\r\n\n";//разделитель
sigsWithMark = new __int32[ExpNotes->addUMark->Tag];//номера сигналов, к которым привязаны метки
markerVsblt = new bool[ExpNotes->addUMark->Tag * ftChan];//видимость меток на каналах
for (i = 0; i < ExpNotes->addUMark->Tag; i++)
{
sigsWithMark[i] = ExpNotes->theMarker->pointOnGraph;
for (j = 0; j < ftChan; j++)
markerVsblt[(i * ftChan) + j] = ExpNotes->theMarker->chanN[j];//видимость меток на каналах
userText += ExpNotes->theMarker->textMark;//текст надписи
userText += "||\n||";
ExpNotes->theMarker = ExpNotes->theMarker->nextM;//переходим к следующей метке
}
}
//=====================================
//параметры сбора данных и прочее
if (saveType)//сохранение только-что проведённого эксперимента
{
//__int32 - параметры
devExpParams_int = new __int32[ehead[2].numOfElements];//создаём массив с параметрами устройства и эксперимента (__int32)
devExpParams_int[0] = multiCh;//0//режим сбора данных (true = многоканальный)
devExpParams_int[1] = recLen;//1//длина развёртки сигнала в отсчётах
devExpParams_int[2] = (__int32)discrT;//2//время дискретизации (микросекунды)
devExpParams_int[3] = chanls;//3//количество сканируемых каналов
devExpParams_int[4] = Experiment->uiLeadChan->ItemIndex;//4//ведущий канал (основной сигнал)
devExpParams_int[5] = Experiment->a.m_nGain;//5//коэффициент усиления
devExpParams_int[6] = ExpNotes->addUMark->Tag * __int32(expType != 5);//6//количество заметок
devExpParams_int[7] = (__int32)experimentType;//7//тип эксперимента, глобальный вариант
devExpParams_int[8] = gPreTime;//8//gPreTime (в микросекундах)
devExpParams_int[9] = gPostTime;//9//gPostTime (в микросекундах)
devExpParams_int[10] = (__int32)gPorog;//10//амплитудный порог (отсчёты)
devExpParams_int[11] = Experiment->maxADCAmp;//11//максимальная амплитуда (в отсчётах)
devExpParams_int[12] = Experiment->minADCAmp;//12//минимальная амплитуда (в отсчётах)
devExpParams_int[13] = Experiment->a.m_nFirstChannel;//13//ведущий аппаратный канал
devExpParams_int[14] = 0;//14//не используется
//float - параметры
devExpParams_float = new float[ehead[3].numOfElements];//создаём массив с параметрами устройства и эксперимента (float)
devExpParams_float[0] = sampl2mV;//0//коэффициент перевода амплитуд из отсчётов АЦП в милливольты = maxVoltage/(maxADCAmp * ADCGain)
devExpParams_float[1] = Experiment->maxVoltage;//1//диапазон входных напряжений (в милливольтах)
devExpParams_float[2] = StrToFloat(Experiment->StimPeriod->Text);//2//период стимуляции
devExpParams_float[3] = discrT;//3//время дискретизации (микросекунды)
devExpParams_float[4] = 0;//4//не используется
devExpParams_float[5] = 0;//5//не используется
}
else//пересохранение
{
devExpParams_int[6] = ExpNotes->addUMark->Tag * (__int32(expType != 5));//количество заметок (меняется)
devExpParams_int[7] = (__int32)experimentType;//тип эксперимента можно поменять (при редактировании)
}
fullSigLen = (recLen * ftChan) + (chanls - ftChan);//суммарная длина развёрток на всех каналах (отсчёты)
dbN = dataInHead;//5//объём экспериментальных данных (все каналы)
ehead[dbN].numOfElements = numOfSignal * (sizeof(float) + (fullSigLen * sizeof(short)));//длина всех развёрток сигналов на всех каналах
dbN++;//6//резерв (объём какого-нибудь блока данных)
ehead[dbN].numOfElements = 0;
dbN++;//7//резерв (объём какого-нибудь блока данных)
ehead[dbN].numOfElements = 0;
dbN++;//8//количество символов в пользовательской "строке" (userText)
ehead[dbN].numOfElements = userText.Length();
dbN++;//9//номера сигналов с метками
ehead[dbN].numOfElements = ExpNotes->addUMark->Tag * (__int32(expType != 5));
dbN++;//10//видимость меток на каналах
ehead[dbN].numOfElements = ftChan * ehead[dbN - 1].numOfElements;
dbN++;//11//резерв (объём какого-нибудь блока данных)
ehead[dbN].numOfElements = 0;
//посчитаем byteInFie
ehead[dataInHead].byteInFile = ehead[eheadSBlock - 1].byteInHead + 1 * ehead[eheadSBlock - 1].szInHDataType;//byteInHead последнего + 4 байта
bytesCounter = ehead[dataInHead].byteInFile;
for (i = dataInHead + 1; i < eheadSBlock; i++)
{
c = ehead[i - 1].numOfElements * ehead[i - 1].szDataType;
bytesCounter += c;
if (ehead[i].numOfElements > 0)
ehead[i].byteInFile = bytesCounter;
else
ehead[i].byteInFile = 0;//нечего записывать
}
//запишем ссылки на переменные и массивы (записываемые в заголовок файла)
dbN = 0;//0//данные о файле
refToWrite[dbN] = progDate.c_str();//данные о файле
dbN++;//1//количество символов в пользовательской "строке" (userText)
refToWrite[dbN] = (__int32*)&ehead[8].numOfElements;//количество байт в userText (8 = eheadSBlock - 4)
//ссылки на массивы с параметрами и номера байтов
dbN++;//2//все int-параметры
refToWrite[dbN] = (__int32*)devExpParams_int;//int-параметры
dbN++;//3//все float-параметры
refToWrite[dbN] = (float*)devExpParams_float;//float-параметры
dbN++;//4//количество сигналов
refToWrite[dbN] = (__int32*)&numOfSignal;//количество сигналов
//экспериментальные данные
dbN++;//5//номер первого байт блока с экспериментальными данными
refToWrite[dbN] = (unsigned long*)&ehead[dbN].byteInFile;
dbN++;//6//резерв (номер первого байт какого-нибудь блока данных)
refToWrite[dbN] = (unsigned long*)&ehead[dbN].byteInFile;
dbN++;//7//резерв (номер первого байт какого-нибудь блока данных)
refToWrite[dbN] = (unsigned long*)&ehead[dbN].byteInFile;
dbN++;//8//номер первого байт блока с текстом, введённым пользователем
refToWrite[dbN] = (unsigned long*)&ehead[dbN].byteInFile;
dbN++;//9//номер первого байт блока с номерами сигналов, к которым прикреплены заметки
refToWrite[dbN] = (unsigned long*)&ehead[dbN].byteInFile;
dbN++;//10//номер первого байт блока с видимостями меток на каналах
refToWrite[dbN] = (unsigned long*)&ehead[dbN].byteInFile;
dbN++;//11//резерв (номер первого байт какого-нибудь блока данных)
refToWrite[dbN] = (unsigned long*)&ehead[dbN].byteInFile;
//=========================================
//файл с расширением *.pra (p - physiological, r - reaction, a - acquisition)
hFile = CreateFile(SaveDlg->FileName.c_str(), GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);//создаём-открываем файл для записи
//=============================
m_nWritten = 0;//число записанных байт
totWrit = 0;//всего записано байт
//записываем заголовок файла
for (i = 0; i < eheadSBlock; i++)
{
if (refToWrite[i])
{
if ((unsigned long)ehead[i].byteInHead != totWrit)
{
Experiment->DevEvents->Text = "ошибка сохранения";
return false;
}
if (i < dataInHead)//данные, располагаемые только в заголовке
WriteFile(hFile, refToWrite[i], (ehead[i].szInHDataType * ehead[i].numOfElements), &m_nWritten, 0);
else//указатели на положения блоков в теле файла
WriteFile(hFile, refToWrite[i], (ehead[i].szInHDataType * 1), &m_nWritten, 0);
totWrit += m_nWritten;
refToWrite[i] = NULL;//на всякий случай зануляем ссылку
}
}
//записываем сигналы
dbN = dataInHead;
frstSignAppear = gSignals[gInd[0]].appear;//время возникновения первого сигнала (в данной записи)
for (i = 0; i < numOfSignal; i++)
{
//развёртки сигналов на всех каналах
gSignals[gInd[i]].appear -= frstSignAppear;//смещаем времена возникновения на время первого сигнала
WriteFile(hFile, (void*)&gSignals[gInd[i]].appear, sizeof(float), &m_nWritten, 0);
totWrit += m_nWritten;
WriteFile(hFile, (void*)&gSignals[gInd[i]].s[0], sizeof(short) * fullSigLen, &m_nWritten, 0);
totWrit += m_nWritten;
}
dbN++;//6//резерв
//WriteFile(hFile, Массив, (ehead[dbN].szDataType * ehead[dbN].numOfElements), &m_nWritten, 0); totWrit += m_nWritten;
dbN++;//7//резерв
//WriteFile(hFile, Массив, (ehead[dbN].szDataType * ehead[dbN].numOfElements), &m_nWritten, 0); totWrit += m_nWritten;
//записываем текстовую информацию, введённую пользователем
dbN++;//8//пользовательские данные
if (ehead[dbN].numOfElements > 0)//!userText.IsEmpty()//строка не пустая
{
WriteFile(hFile, (void*)userText.c_str(), (ehead[dbN].szDataType * ehead[dbN].numOfElements), &m_nWritten, 0);
totWrit += m_nWritten;
}
if ((ExpNotes->addUMark->Tag > 0) && (expType != 5))
{
dbN++;//9//номера сигналов с заметками
WriteFile(hFile, (void*)&sigsWithMark[0], (ehead[dbN].szDataType * ehead[dbN].numOfElements), &m_nWritten, 0);
totWrit += m_nWritten;
dbN++;//10//видимость меток на каналах
WriteFile(hFile, (void*)&markerVsblt[0], (ehead[dbN].szDataType * ehead[dbN].numOfElements), &m_nWritten, 0);
totWrit += m_nWritten;
delete[] sigsWithMark; sigsWithMark = NULL;//номера сигналов, которым привязаны метки
delete[] markerVsblt; markerVsblt = NULL;//видимость меток на каналах
}
else
dbN += 2;//необходимое приращение индекса
dbN++;//11//резерв
//WriteFile(hFile, Массив, (ehead[dbN].szDataType * ehead[dbN].numOfElements), &m_nWritten, 0); totWrit += m_nWritten;
CloseHandle(hFile); hFile = NULL;//закрываем файл
//сравниваем число записанных байти, с общим размером данных (в байтах)
m_nWritten = 0;
for (g = 0; g < eheadSBlock; g++)
{
if (g > (dataInHead - 1))//данные есть в заголовке и в теле файла
m_nWritten += ehead[g].szInHDataType * 1;
m_nWritten += ehead[g].szDataType * ehead[g].numOfElements;
}
if (m_nWritten != totWrit)//если не совпало, значит где-то ошиблись
{
Experiment->DevEvents->Text = "ошибка сохранения";
return false;
}
//рассчитаем параметры сигналов для отображения
//Calculate(trac *sgnl, __int32 numOfS, short porog, __int32 preTime, __int32 postTime,
// __int32 *inds, short expT, bool newNull, short chn, sPr *avrP)
Calculate(gSignals, numOfSignal, gPorog, gPreTime, gPostTime, gInd, experimentType, false, NULL);
Graphs->Caption = "Графики - " + SaveDlg->FileName;//дополняем название окна названием файла
return true;
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::ReadDataFile(TObject *Sender)
{
//чтение файла с данными (файл типа *.pra)
bool forwc,//индикатор успешности чтения блока данных из файла
*markerVsblt,//видимость меток на каналах
maxMultiChann,//многоканальность (хотябы для одного сигнала)
mOnChn[maxChannels];//привязка меток к каналам
unsigned long bytesRead,
totRead,//всего прочитано байт
*beginBytes;//массив с номерами начальных байтов блоков с экспериментальными данными
__int32 i, j, k, z,
fullSigLen,//суммарная длина сигналов со всех каналов
dbN,//номер блока данных
*sigsWithMark,//номера сигналов, к которым привязаны метки
lettersNum,//количество символов в тексте пользователя
maxToRec,//максимальная длина сигнала (в отсчётах)
maxChanNumb,//максимальное количество каналов
numOfSignal;//число сигналов
AnsiString allUsersTxt,//информация, вводимая пользователем
usersComent,//общий коментарий
usersMarks,//заметки по ходу эксперимента
singlMark;//нарезаем заметки
char *unote,//информация, вводимая пользователем
*pidate;//информация о программе и даты (Programm Information and Date)
short expType;//тип эксперимента
HANDLE hFile;//хэндл файла, из которого читаем данные
totRead = 0;//всего прочитано байт
beginBytes = NULL; sigsWithMark = NULL; markerVsblt = NULL; unote = NULL; pidate = NULL;
//открываем и читаем файл с экспериментальными данными
hFile = CreateFile(OpenDlg->FileName.c_str(), GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
pidate = new char[ehead[0].numOfElements];//готовим массивы для записи данных из файла
//чтение блока №0 (самое начало)
dbN = 0;
forwc = ReadFile(hFile, (void*)pidate, (ehead[dbN].numOfElements * ehead[dbN].szDataType), &bytesRead, 0);
totRead += bytesRead;
if (!forwc)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
//проверяем версию формата файла
singlMark = pidate;
j = singlMark.AnsiPos("ElphAcqu v3.9");//поддерживаемый формат
j += singlMark.AnsiPos("ElphAcqu v4.");//поддерживаемый формат
j += singlMark.AnsiPos("ElphAcqu v5.");//поддерживаемый формат
if (j <= 0)//нет такой строки в файле
{
delete[] pidate; pidate = NULL;
CloseHandle(hFile);//закрываем файл и удаляем все объекты созданные оператором new
Experiment->DevEvents->Text = "формат не поддерживается";//ReadOldFormatFile(this);//читаем как pra-файл старого формата
return;
}
ExpNotes->PIDates->Lines->SetText(pidate);//загружаем текст в поле типа TMemo
//готовим массивы для записи данных из файла
beginBytes = new unsigned long[pureData];//храним pureData измеряемых величин (пока не больше)
devExpParams_int = new __int32[ehead[2].numOfElements];//создаём массив с параметрами устройства и эксперимента (__int32)
devExpParams_float = new float[ehead[3].numOfElements];//создаём массив с параметрами устройства и эксперимента (float)
dbN++;//1//чтение блока №1
if ((unsigned long)ehead[dbN].byteInHead != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
lettersNum = 0;
forwc = ReadFile(hFile, (void*)&lettersNum, (ehead[dbN].numOfElements * ehead[dbN].szDataType), &bytesRead, 0);
totRead += bytesRead;
dbN++;//2//чтение блока №2
if ((unsigned long)ehead[dbN].byteInHead != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
forwc = ReadFile(hFile, (void*)devExpParams_int, (ehead[dbN].numOfElements * ehead[dbN].szDataType), &bytesRead, 0);
totRead += bytesRead;
dbN++;//3//чтение блока №3
if ((unsigned long)ehead[dbN].byteInHead != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
forwc = ReadFile(hFile, (void*)devExpParams_float, (ehead[dbN].numOfElements * ehead[dbN].szDataType), &bytesRead, 0);
totRead += bytesRead;
dbN++;//4//чтение блока №4 (количество сигналов)
if ((unsigned long)ehead[dbN].byteInHead != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
numOfSignal = 0;
forwc = ReadFile(hFile, (void*)&numOfSignal, 1 * ehead[dbN].szDataType, &bytesRead, 0);
totRead += bytesRead;
SigNumUpDwn->Tag = numOfSignal;//храним исходное число сигналов (нужно при удалении ссылок)
SigNumUpDwn->Max = numOfSignal;//задаём пределы изменения номеров сигналов (оставшихся после редактирования)
/* последовательность данных в массивах devExpParams_int и devExpParams_float
//__int32 - параметры
devExpParams_int[0] = multiCh;//0//режим сбора данных (true = многоканальный)
devExpParams_int[1] = recLen;//1//длина развёртки сигнала в отсчётах
devExpParams_int[2] = (__int32)discrT;//2//время дискретизации (микросекунды)
devExpParams_int[3] = chanls;//3//количество сканируемых каналов
devExpParams_int[4] = Experiment->uiLeadChan->ItemIndex;//4//ведущий канал (основной сигнал)
devExpParams_int[5] = Experiment->adcGain;//5//коэффициент усиления
devExpParams_int[6] = ExpNotes->addUMark->Tag * (__int32(expType != 5));//6//количество заметок
devExpParams_int[7] = experimentType;//7//тип эксперимента, глобальный вариант
devExpParams_int[8] = gPreTime;//8//gPreTime (в микросекундах)
devExpParams_int[9] = gPostTime;//9//gPostTime (в микросекундах)
devExpParams_int[10] = (__int32)gPorog;//10//амплитудный порог (отсчёты)
devExpParams_int[11] = Experiment->maxADCAmp;//11//максимальная амплитуда (в отсчётах)
devExpParams_int[12] = Experiment->minADCAmp;//12//минимальная амплитуда (в отсчётах)
devExpParams_int[13] = Experiment->a.m_nFirstChannel;//13//ведущий аппаратный канал
devExpParams_int[14] = 0;//14//не используется
//float - параметры
devExpParams_float[0] = sampl2mV;//0//коэффициент перевода амплитуд из отсчётов АЦП в милливольты = maxVoltage/(maxADCAmp * ADCGain)
devExpParams_float[1] = Experiment->maxVoltage;//1//диапазон входных напряжений (в милливольтах)
devExpParams_float[2] = StrToFloat(Experiment->stimPeriod->Text);//2//период стимуляции
devExpParams_float[3] = discrT;//3//время дискретизации (микросекунды)
devExpParams_float[4] = 0;//4//не используется
devExpParams_float[5] = 0;//5//не используется*/
//атрибуты сигналов
multiCh = (bool)devExpParams_int[0];//режим сбора данных (true = многоканальный)
recLen = devExpParams_int[1];//длина развёртки сигнала в отсчётах
discrT = devExpParams_float[3];//время дискретизации (микросекунды)
if (discrT < 1e-6)//читай если discrT == 0
discrT = devExpParams_int[2];//время дискретизации (микросекунды)
chanls = devExpParams_int[3];//количество сканируемых каналов
ftChan = 1 + (chanls - 1) * (__int32)multiCh;//количество каналов с полными развёртками
effDT = discrT * (float)chanls;//эффективное время дискретизации = discrT * chanls
fullSigLen = (recLen * ftChan) + (chanls - ftChan);//суммарная длина развёрток на всех каналах (отсчёты)
sampl2mV = devExpParams_float[0];//коэффициент перевода амплитуд из отсчётов АЦП в милливольты = maxVoltage/(maxADCAmp * ADCGain)
if (fabs(sampl2mV - (devExpParams_float[1] / (devExpParams_int[11] * devExpParams_int[5]))) > 1e-4)//не сходится
{
sampl2mV = devExpParams_float[1] / float(devExpParams_int[11] * devExpParams_int[5]);//коэффициент усиления
Experiment->DevEvents->Text = "коэффициент";
}
//другие важные параметры
experimentType = (short)devExpParams_int[7];//копируем тип эксперимента в глобальную переменную
gPreTime = devExpParams_int[8];//ПРЕ-время (микросекунды)
gPostTime = devExpParams_int[9];//ПОСТ-время (микросекунды)
gPorog = (short)devExpParams_int[10];//амплитудный порог (отсчёты)
//определяем начальный индекс для рисования
gTimeBgn = 0;
if (experimentType == 2)
gTimeBgn = gPostTime;
else if (experimentType == 3)
gTimeBgn = gPreTime;
//чтение номеров байтов с блоками экспериментальных данных
//эти pureData штук элементов имеют формат unsigned long
dbN = dataInHead;//5
if ((unsigned long)ehead[dbN].byteInHead != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
forwc = ReadFile(hFile, (void*)beginBytes, pureData * ehead[dbN].szInHDataType, &bytesRead, 0);
totRead += bytesRead;
gSignals = CreatStructSignal(numOfSignal, recLen);//создаём структуру с параметрами сигналов
gInd = new __int32[numOfSignal];//создаём массив с номерами доступных сигналов
//считываем сигналы и параметры
dbN = dataInHead;
if (beginBytes[dbN - dataInHead] != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
for (i = 0; i < numOfSignal; i++)
{
gInd[i] = i;//заполняем массив с номерами доступных сигналов
ReadFile(hFile, (void*)&gSignals[i].appear, sizeof(float), &bytesRead, 0);
totRead += bytesRead;
ReadFile(hFile, gSignals[i].s, sizeof(short) * fullSigLen, &bytesRead, 0);
totRead += bytesRead;
}
//резерв (пока нечего читать)
dbN++;//6//
//ReadFile(hFile, (void*)unote, (ehead[dbN].szDataType * ehead[dbN].numOfElements), &bytesRead, 0); totRead += bytesRead;
dbN++;//7//
//ReadFile(hFile, (void*)unote, (ehead[dbN].szDataType * ehead[dbN].numOfElements), &bytesRead, 0); totRead += bytesRead;
dbN++;//8//читаем текстовую информацию, введённую пользователем
if ((lettersNum > 0) && (beginBytes[dbN - dataInHead] > 0))
{
//должно быть: dbN = 8//dbN = dataInHead + 3;//8
if (beginBytes[dbN - dataInHead] != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
unote = new char[lettersNum];//в lettersNum записано количество байт в пользовательской строке
ReadFile(hFile, (void*)unote, (ehead[dbN].szDataType * lettersNum), &bytesRead, 0);
totRead += bytesRead;
allUsersTxt = "";
for (i = 0; i < (__int32)bytesRead; i++)//bytesRead = lettersNum
allUsersTxt += unote[i];
//определяем положение разделителя ("\n\n\r\r\n\n")
//до этого символа идёт коментарий, а после него - заметки по ходу эксперимента
j = allUsersTxt.AnsiPos("\n\n\r\r\n\n");
usersComent = allUsersTxt;
usersComent.Delete(j, usersComent.Length());//коментарий к эксперименту
ExpNotes->usersNotes->Lines->Text = usersComent;//загружаем текст в поле TMemo
if (!usersComent.IsEmpty())//естрока не пуста
usersInfoClick(this);//откроем блокнот
delete[] unote; unote = NULL;
}
dbN++;//9//номера сигналов, к которым привязаны метки //должно быть: dbN = 9//dbN = dataInHead + 4;//9
if ((devExpParams_int[6] > 0) && (beginBytes[dbN - dataInHead] > 0))
{
if (beginBytes[dbN - dataInHead] != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
sigsWithMark = new __int32[devExpParams_int[6]];//массив с номерами сигналов, к которым привязаны заметки
ReadFile(hFile, (void*)sigsWithMark, (ehead[dbN].szDataType * devExpParams_int[6]), &bytesRead, 0);
totRead += bytesRead;
dbN++;//10//видимость меток на каналах
if (beginBytes[dbN - dataInHead] > 0)
{
if (beginBytes[dbN - dataInHead] != totRead)
{ Experiment->DevEvents->Text = "ошибка чтения"; return; }
markerVsblt = new bool[devExpParams_int[6] * ftChan];//видимость меток на каналах
ReadFile(hFile, (void*)markerVsblt, (ehead[dbN].szDataType * devExpParams_int[6] * ftChan), &bytesRead, 0); totRead += bytesRead;
totRead += bytesRead;
}
//выставляем метки, если таковые имеются
usersMarks = allUsersTxt;
usersMarks.Delete(1, j + 5);//вырезаем всё, кроме меток (j - положение разделительное строки)
j = 1;//затравочное значение
z = 0;//счётчик меток
for (i = 0; ((i < devExpParams_int[6]) && (j > 0)); i++)//цикл по количеству пользовательских меток
{
j = usersMarks.AnsiPos("||\n||");//ищем разделители между заметками
if (j > 0)
{
singlMark = usersMarks;//копируем оставшуюся часть записи
singlMark.Delete(j, singlMark.Length() - (j - 2));//вырезаем обработанную метку
if (markerVsblt)
for (k = 0; k < ftChan; k++)//привязываем метку к нужному каналу
mOnChn[k] = markerVsblt[(ftChan * z) + k];//привязываем метку к нужному каналу
else
for (k = 0; k < ftChan; k++)//привязываем метку ко всем каналам
mOnChn[k] = true;//привязываем метку ко всем каналам
ExpNotes->AddMarker(singlMark, sigsWithMark[i], &mOnChn[0]);//добавляем метку
usersMarks.Delete(1, j + 4);//удаляем из оставшегося текста обработанную метку
z++;//увеличиваем счётчик меток
}
}
delete[] sigsWithMark; sigsWithMark = NULL;
delete[] markerVsblt; markerVsblt = NULL;
}
else
dbN += 1;//необходимое приращение индекса
dbN++;//11//
//ReadFile(hFile, (void*)unote, (ehead[dbN].szDataType * ehead[dbN].numOfElements), &bytesRead, 0); totRead += bytesRead;
//закрываем файл и удаляем все объекты созданные оператором new
CloseHandle(hFile);
delete[] beginBytes; beginBytes = NULL;
delete[] pidate; pidate = NULL;
gRF[0] = 0;//первый отображаемый сигнал
gRF[1] = ftChan;//последний отображаемый сигнал (отображаем все каналы ftChan)
Calculate(gSignals, numOfSignal, gPorog, gPreTime, gPostTime, gInd, experimentType, false, NULL);//рассчитаем параметры сигналов для отображения
GraphsTabsShow();//открываем окно с графиками
Graphs->Caption = "Графики - " + OpenDlg->FileName;//дополняем название окна названием файла
if (ftChan > 1)
{
SAllChan->Checked = false;//для выводимости
SAllChanClick(this);//выводим все каналы
}
else
ChannNumb[0]->Click();//выводим первый канал
//FillParamTable();//заполняем таблицу значениями параметров
//ResetVisibility();//запускаем прорисовку графиков
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::ReadLineData(TObject *Sender)
{
//чтение файла с данными (файл типа *.drr)
FILE *discontinFile;
unsigned long totRead;//всего прочитано байт
__int32 i, j, z,
k,//счётчик сигналов
*locRecLen,//длина развёртки сигнала в отсчётах
locChanls,//количество сканируемых каналов
*locAdcGain,//коэффициент усиления
maxG,//максимальный коэффициент усиления
fullSigLen,//полная длина данных со всех каналов (отсчёты)
nUserMrk,//количество пользовательских меток
nBlocks,//количество блоков (сеансов записи)
firstPInBlk,//номер первой точки в текущем блоке
comMrkNum,//счёткчик заметок по ходу эксперимента
itemRd,//количество прочитанных единиц (не байт)
*sigsWithMark,//массив с номерами сигналов, к которым привязаны заметки
*brdSig,//номера сигналов граничных между блоками
lettersNum,//количество символов в тексте пользователя
locMrkNum,//локальное колчиество заметок
numOfSignal;//число сигналов
AnsiString allUsersTxt,//информация, вводимая пользователем
usersComent,//общий коментарий
usersMarks,//заметки по ходу эксперимента
singlMark;//нарезаем заметки
float locDiscrT,//время дискретизации
timeSepar;//разделитель по времени
TDateTime CurrentDateTime;//это текущие дата и время
char lett[3],//идентификатор параметра или сигнала
*pidate,//информация о программе и даты (Programm Information and Date)
*unote;//информация, вводимая пользователем
short expType;//тип эксперимента
bool boolBuf,//первое определение атрибутов сигналов
locMultiCh,//режим сбора данных (true = многоканальный)
mOnChn[maxChannels];//привязка меток к каналам
maxG = 0;//максимальный коэффициент усиления
boolBuf = true;//первое определение атрибутов сигналов
totRead = 0;//всего прочитано байт
//готовим массивы для записи данных из файла
pidate = new char[ehead[0].numOfElements];
devExpParams_int = new __int32[ehead[2].numOfElements];//создаём массив с параметрами устройства и эксперимента (__int32)
devExpParams_float = new float[ehead[3].numOfElements];//создаём массив с параметрами устройства и эксперимента (float)
discontinFile = fopen(OpenDlg->FileName.c_str(), "rb");//открываем для чтения файл с экспериментальными данными
if (discontinFile == NULL)
{ Experiment->DevEvents->Text = "ошибка открытия файла"; return; }
numOfSignal = 0;//счётчик числа сигналов
nUserMrk = 0;//общее количество сигналов
nBlocks = 1;//счётчик блоков (сеансов записи)
//сначала подсчитаем количество сигнало и прочее
//читаем запись о датах создания и изменения файла
itemRd = fread((void*)pidate, ehead[0].szDataType, ehead[0].numOfElements, discontinFile);//
ExpNotes->PIDates->Lines->Text = pidate;
//идём на начало файла и начинаем искать идентификаторы
itemRd = fseek(discontinFile, 0, SEEK_SET);//переход на начало файла
itemRd = fread(&lett, 1, 3, discontinFile);//
while (itemRd > 0)
{
lett[0] = lett[1]; lett[1] = lett[2];
itemRd = fread(&lett[2], 1, 1, discontinFile);//идентификатор
if ((lett[0] == 'P') && (lett[1] == 'r') && (lett[2] == 'M') && boolBuf)//метка блока с параметрами (первое определение атрибутов сигналов)
{
/* последовательность записи обязательных параметров
multiCh -------(1) - режим сбора данных (true = многоканальный)
recLen --------(2) - длина развёртки сигнала (отсчёты)
discrT --------(3) - время дискретизации
chanls --------(4) - количество сканируемых каналов
E->adcGain ----(5) - коэффициент усиления
experimentType (6) - тип эксперимента, глобальный вариант
E->maxVoltage -(7) - диапазон напряжений
E->maxADCAmp --(8) - максимальная амплитуда (отсчёты) */
itemRd = fread(&multiCh, sizeof(bool), 1, discontinFile);//1//режим сбора данных (true = многоканальный)
itemRd = fread(&recLen, sizeof(__int32), 1, discontinFile);//2//длина сигнала (отсчёты)
itemRd = fread(&discrT, sizeof(float), 1, discontinFile);//3//время дискретизации
itemRd = fread(&chanls, sizeof(__int32), 1, discontinFile);//4//количество используемых каналов
itemRd = fread(&devExpParams_int[5], sizeof(__int32), 1, discontinFile);//5//коэффициент усиления
itemRd = fread(&expType, sizeof(short), 1, discontinFile);//6//тип эксперимента
devExpParams_int[7] = expType;//тип эксперимента
itemRd = fread(&devExpParams_float[1], sizeof(float), 1, discontinFile);//7//диапазон напряжений
itemRd = fread(&devExpParams_int[11], sizeof(__int32), 1, discontinFile);//8//максимальная амплитуда (отсчёты)
boolBuf = false;//первое определение атрибутов сигналов
sampl2mV = devExpParams_float[1] / float(devExpParams_int[11] * devExpParams_int[5]);//коэффициента пересчёта амплитуд
devExpParams_float[0] = sampl2mV;//0//коэффициент перевода амплитуд из отсчётов АЦП в милливольты = maxVoltage/(maxADCAmp * ADCGain)
ftChan = 1 + (chanls - 1) * (__int32)multiCh;//количество каналов с полными развёртками
effDT = discrT * (float)chanls;//эффективное время дискретизации = discrT * chanls
fullSigLen = (recLen * ftChan) + (ftChan - chanls);//полная длина данных со всех каналов (отсчёты)
}
else if ((lett[0] == 'M') && (lett[1] == 'r') && (lett[2] == 'k'))//область с заметками по ходу эксперимента
{
//читаем заметки по ходу эксперимента, если такие были
/* последовательность записи в блоке с текстовыми данных
lettersNum -(1) - длина текстовой записи
comUserMakrs(2) - количество заметок по ходу эксперимента
userText ---(3) - текст об эксперименте и заметке по ходу
sigsWithMark(4) - массив с номерами точек с заметками
*/
itemRd = fread(&z, sizeof(__int32), 1, discontinFile);//1//длина текстовой записи
itemRd = fread(&z, sizeof(__int32), 1, discontinFile);//2//количество заметок
nUserMrk += z;//счётчик пользовательских заметок по ходу эксперимента
}
else if ((lett[0] == 'S') && (lett[1] == 'i') && (lett[2] == 'g'))//сам сигнал
numOfSignal++;//счётчик числа сигналов
else if ((lett[0] == 'E') && (lett[1] == 'D') && (lett[2] == ':'))//разделитель между сеансами сбора данных
nBlocks++;//прирост количества блоков
}
//определяем другие глобальные переменные (необязательные)
gPreTime = 0; gPostTime = 0; gPorog = 0;
gTimeBgn = 0;
//режим №4 лучше использовать только в стандартном (pra) режиме
/* последовательность данных в массивах devExpParams_int и devExpParams_float
//__int32 - параметры
devExpParams_int[0] = multiCh;//0//режим сбора данных (true = многоканальный)
devExpParams_int[1] = recLen;//1//длина развёртки сигнала в отсчётах
devExpParams_int[2] = (__int32)discrT;//2//время дискретизации (микросекунды)
devExpParams_int[3] = chanls;//3//количество сканируемых каналов
devExpParams_int[4] = Experiment->uiLeadChan->ItemIndex;//4//ведущий канал (основной сигнал)
devExpParams_int[5] = Experiment->adcGain;//5//коэффициент усиления
devExpParams_int[6] = ExpNotes->addUMark->Tag * (__int32(expType != 5));//6//количество заметок
devExpParams_int[7] = experimentType;//7//тип эксперимента, глобальный вариант
devExpParams_int[8] = gPreTime;//8//gPreTime (в микросекундах)
devExpParams_int[9] = gPostTime;//9//gPostTime (в микросекундах)
devExpParams_int[10] = (__int32)gPorog;//10//амплитудный порог (отсчёты)
devExpParams_int[11] = Experiment->maxADCAmp;//11//максимальная амплитуда (в отсчётах)
devExpParams_int[12] = Experiment->minADCAmp;//12//минимальная амплитуда (в отсчётах)
devExpParams_int[13] = Experiment->a.m_nFirstChannel;//13//ведущий аппаратный канал
devExpParams_int[14] = 0;//14//не используется
//float - параметры
devExpParams_float[0] = sampl2mV;//0//коэффициент перевода амплитуд из отсчётов АЦП в милливольты = maxVoltage/(maxADCAmp * ADCGain)
devExpParams_float[1] = Experiment->maxVoltage;//1//диапазон входных напряжений (в милливольтах)
devExpParams_float[2] = StrToFloat(Experiment->stimPeriod->Text);//2//период стимуляции
devExpParams_float[3] = discrT;//3//время дискретизации (микросекунды)
devExpParams_float[4] = 0;//4//не используется
devExpParams_float[5] = 0;//5//не используется*/
//вписываем параметры в массивы devExpParams_int и devExpParams_float
//__int32 - параметры
devExpParams_int[4] = 0;//4//ведущий канал (основной сигнал)
devExpParams_int[6] = nUserMrk + nBlocks;//6//количество пользовательских меток (+ количество блоков (сеансов) записи)
devExpParams_int[8] = gPreTime;//8//gPreTime (в микросекундах)
devExpParams_int[9] = gPostTime;//9//gPostTime (в микросекундах)
devExpParams_int[10] = (__int32)gPorog;//10//амплитудный порог (отсчёты)
devExpParams_int[12] = -devExpParams_int[11];//12//минимальная амплитуда (в отсчётах)
devExpParams_int[13] = Experiment->a.m_nFirstChannel;//13//ведущий аппаратный канал
devExpParams_int[14] = 0;//14//не используется
//float - параметры
devExpParams_float[4] = 0;//4//не используется
devExpParams_float[5] = 0;//5//не используется
SigNumUpDwn->Tag = numOfSignal;//храним исходное число сигналов (нужно при удалении ссылок)
SigNumUpDwn->Max = numOfSignal;//задаём пределы изменения номеров сигналов (оставшихся после редактирования)
gSignals = CreatStructSignal(numOfSignal, recLen);//создаём структуру для хранения данных
//идём на начало файла и начинаем искать идентификаторы
itemRd = fseek(discontinFile, 0, SEEK_SET);//переход на начало файла
locRecLen = new __int32[nBlocks];//длина развёртки сигнала в отсчётах
locAdcGain = new __int32[nBlocks];//коэффициент усиления
brdSig = new __int32[nBlocks + 1];//номера сигналов граничных между блоками
k = 0;//сквозной счётчик прочитанных сигналов
firstPInBlk = -1;//флаг
comMrkNum = 0;//счёткчик заметок по ходу эксперимента
nBlocks = 1;//снова открываем счётчик блоков (сеансов записи)
//newBlock = false;//наиден новый блок
timeSepar = 0;//корректировка времени возникновения
gInd = new __int32[numOfSignal];//здесь же заодно сформируем массив индексов
itemRd = fread(&lett, 1, 3, discontinFile);//
while (itemRd > 0)
{
lett[0] = lett[1]; lett[1] = lett[2];
itemRd = fread(&lett[2], 1, 1, discontinFile);//идентификатор
if ((lett[0] == 'P') && (lett[1] == 'r') && (lett[2] == 'M'))//метка блока с параметрами
{
/* последовательность записи обязательных параметров
multiCh -------(1) - режим сбора данных (true = многоканальный)
recLen --------(2) - длина развёртки сигнала (отсчёты)
discrT --------(3) - время дискретизации
chanls --------(4) - количество сканируемых каналов
E->adcGain ----(5) - коэффициент усиления
experimentType (6) - тип эксперимента, глобальный вариант
E->maxVoltage -(7) - диапазон напряжений
E->maxADCAmp --(8) - максимальная амплитуда (отсчёты) */
itemRd = fread(&locMultiCh, sizeof(bool), 1, discontinFile);//режим сбора данных (true = многоканальный)
itemRd = fread(&locRecLen[nBlocks - 1], sizeof(__int32), 1, discontinFile);//длина развёртки сигнала в отсчётах
itemRd = fread(&locDiscrT, sizeof(float), 1, discontinFile);//время дискретизации
itemRd = fread(&locChanls, sizeof(__int32), 1, discontinFile);//количество сканируемых каналов
itemRd = fread(&locAdcGain[nBlocks - 1], sizeof(__int32), 1, discontinFile);//коэффициент усиления
itemRd = fread(&experimentType, sizeof(short), 1, discontinFile);//тип эксперимента
if ((multiCh != locMultiCh) || (recLen != locRecLen[nBlocks - 1]) || (discrT != locDiscrT) ||
(chanls != locChanls) || (devExpParams_int[5] != locAdcGain[nBlocks - 1]))//обнаружены новые параметры
{
/*?сохраняем предыдущий блок данных как отдельный файл и закрываем его?*/
multiCh = locMultiCh;//режим сбора данных (true = многоканальный)
recLen = locRecLen[nBlocks - 1];//длина развёртки сигнала в отсчётах
discrT = locDiscrT;//время дискретизации
chanls = locChanls;//количество сканируемых каналов
devExpParams_int[0] = (__int32)multiCh;//0//многоканальность (хотябы для одного файла)
devExpParams_int[1] = recLen;//1//длина развёртки сигнала в отсчётах
devExpParams_int[2] = (__int32)discrT;//2//время дискретизации (микросекунды)
devExpParams_int[3] = chanls;//3//количество сканируемых каналов
devExpParams_int[5] = locAdcGain[nBlocks - 1];//коэффициент усиления
devExpParams_int[6] = nUserMrk + nBlocks;//6//количество пользовательских меток (+ количество блоков (сеансов) записи)
devExpParams_int[7] = experimentType;//7//тип эксперимента, глобальный вариант
sampl2mV = devExpParams_float[1] / float(devExpParams_int[11] * devExpParams_int[5]);//коэффициента пересчёта амплитуд
devExpParams_float[0] = sampl2mV;//0//коэффициент перевода амплитуд из отсчётов АЦП в милливольты = maxVoltage/(maxADCAmp * ADCGain)
devExpParams_float[3] = discrT;//3//время дискретизации (микросекунды)
ftChan = 1 + (locChanls - 1) * (__int32)locMultiCh;//количество каналов с полными развёртками
effDT = discrT * (float)chanls;//эффективное время дискретизации = discrT * chanls
fullSigLen = (locRecLen[nBlocks - 1] * ftChan) + (ftChan - locChanls);//полная длина данных со всех каналов (отсчёты)
}
firstPInBlk = k;//номер первой точки в текущем блоке
brdSig[nBlocks - 1] = k;//номер сигнала граничного между блоками
//newBlock = true;//наиден новый блок
if (locAdcGain[nBlocks - 1] > maxG)
maxG = locAdcGain[nBlocks - 1];//максимальный коэффициент усиления
}
else if (((lett[0] == 'S') && (lett[1] == 'i') && (lett[2] == 'g')) && (k < numOfSignal))//сам сигнал
{
itemRd = fread(&gSignals[k].appear, sizeof(float), 1, discontinFile);//время возникновения сигнала
totRead += itemRd * sizeof(float);
gSignals[k].appear += timeSepar;//разделение блоков односекундным интервалом
itemRd = fread(gSignals[k].s, sizeof(short), fullSigLen, discontinFile);
totRead += itemRd * fullSigLen * sizeof(short);
/*if (newBlock)
{ singlMark = "блок№";//метка начала блока
singlMark += IntToStr(nBlocks);
ExpNotes->AddMarker(singlMark, firstPInBlk);
newBlock = false;//наиден новый блок }*/
gInd[k] = k;//здесь же заодно сформируем массив индексов
k++;//увеличиваем счётчик прочитанных сигналов
}
else if ((lett[0] == 'M') && (lett[1] == 'r') && (lett[2] == 'k'))//область с заметками по ходу эксперимента
{
//добавляем в переменную userText заметки по ходу эксперимента из читаемого сеанса
//читаем заметки по ходу эксперимента, если такие были
/* последовательность записи в блоке с текстовыми данных
lettersNum --(1) - длина текстовой записи
comUserMakrs-(2) - количество заметок по ходу эксперимента
userText ----(3) - текст об эксперименте и заметке по ходу
sigsWithMark-(4) - массив с номерами точек с заметками
*/
itemRd = fread(&z, sizeof(__int32), 1, discontinFile);//1//длина текстовой записи
unote = new char[z];//место под текст (весь)
itemRd = fread(&locMrkNum, sizeof(__int32), 1, discontinFile);//2//locMrkNum - локальное колчиество заметок
//чтение текстовых данных
itemRd = fread((void*)unote, sizeof(char), z, discontinFile);//3//весь текст
allUsersTxt = "";
for (i = 0; i < z; i++)//bytesRead = lettersNum
allUsersTxt += unote[i];
//определяем положение разделителя ("\n\n\r\r\n\n")
//до этого символа идёт коментарий, а после него - заметки по ходу эксперимента
j = allUsersTxt.AnsiPos("\n\n\r\r\n\n");
usersComent = allUsersTxt;
usersComent.Delete(j, usersComent.Length());//коментарий к эксперименту
ExpNotes->usersNotes->Lines->Text = usersComent;//загружаем текст в поле TMemo
if (!usersComent.IsEmpty())//строка не пуста
usersInfoClick(this);//откроем блокнот //ExpNotes->Show();
usersMarks = allUsersTxt;
usersMarks.Delete(1, j + 5);//заметки по ходу эксперимента (расставляем в конце, после прорисовки графиков)
//читаем номера сигналов, к которым привязаны заметки (если таковые имеются)
if ((locMrkNum > 0) && (!usersMarks.IsEmpty()))//оставшаяся строка содержит данные
{
sigsWithMark = new __int32[locMrkNum];//массив с номерами сигналов, к которым привязаны заметки
itemRd = fread((void*)sigsWithMark, sizeof(__int32), locMrkNum, discontinFile);//4//номера точек с заметками
j = 1;//счётчик символов
for (i = 0; ((i < locMrkNum) && (comMrkNum < devExpParams_int[6])); i++)
{
j = usersMarks.AnsiPos("||\n||");//ищем разделители между заметками
if (j > 0)
{
singlMark = usersMarks;//копируем весь оставшийся текст
singlMark.Delete(j, singlMark.Length() - (j - 2));//вырезаем текст метки
if ((singlMark.AnsiPos("нБ") == 1) && (singlMark.Length() <= 2))//метка является разделителем блоков
{
singlMark = "Б№";//меняем "безликий" разделитель блоков на нумерной
singlMark += IntToStr(nBlocks);//добавляем номре сеанса сбора данных
}
//по отдельности читаем видимость для каждой метки
itemRd = fread((void*)mOnChn, sizeof(bool), ftChan, discontinFile);//4//номера точек с заметками
ExpNotes->AddMarker(singlMark, firstPInBlk + sigsWithMark[i], &mOnChn[0]);//добавляем метку
usersMarks.Delete(1, j + 4);//вырезаем добавленную метку и разделитель ||\n||
}
comMrkNum++;//общий счётчик заметок по ходу эксперимента
}
delete[] sigsWithMark; sigsWithMark = NULL;
}
delete[] unote; unote = NULL;
}
else if ((lett[0] == 'E') && (lett[1] == 'D') && (lett[2] == ':'))//разделитель между блоками
{
timeSepar = (gSignals[k - 1].appear + 1);//между блоками вставляем интервал времени 1 секунда
nBlocks++;//счётчик блоков
}
}
SigNumUpDwn->Max = k;//количество безошибочно прочитанных сигналов
fclose(discontinFile);//закрываем файл
delete[] pidate; pidate = NULL;
brdSig[nBlocks] = k;//для совместимости
for (i = 0; i < nBlocks; i++) //перебираем блоки
{
for (k = brdSig[i]; k < brdSig[i + 1]; k++)
{
for (j = 0; j < recLen; j++)
gSignals[k].s[j] = (short)floor((gSignals[k].s[j] * (maxG / locAdcGain[i])) + 0.5);
}
}
devExpParams_int[5] = maxG;//коэффициент усиления
sampl2mV = devExpParams_float[1] / float(devExpParams_int[11] * devExpParams_int[5]);//коэффициента пересчёта амплитуд
gRF[0] = 0;//первый отображаемый сигнал
gRF[1] = ftChan;//последний отображаемый сигнал (отображаем все каналы ftChan)
Calculate(gSignals, numOfSignal, gPorog, gPreTime, gPostTime, gInd, experimentType, false, NULL);//рассчитаем параметры сигналов для отображения
GraphsTabsShow();//открываем окно с графиками
Graphs->Caption = "Графики - " + OpenDlg->FileName;//дополняем название окна названием файла
if (ftChan > 1)
SAllChanClick(this);//выводим все каналы
else
ChannNumb[0]->Click();//выводим первый канал
//FillParamTable();//заполняем таблицу значениями параметров
//ResetVisibility();//запускаем прорисовку графиков
}
//---------------------------------------------------------------------------
void TGraphs::GraphsTabsShow()
{
//высвечиваем окно с графиками (таблицами)
__int32 i;
if (gSignals)
{
if (Experiment->TabsCheck->Checked)
{
pValues->Visible = true;//видна будет таблица
//выделяем соответствующую ячейку таблицы
pValues->Row = SigNumUpDwn->Position;//номер сигнала для пользователя (видимый номер)
pValues->Col = 1;
}
else
pValues->Visible = false;//таблицу скрываем
//формируем список каналов доступных для просмотра
for (i = 0; i < maxChannels; i++)
{
if (i < ftChan)
ChannNumb[i]->Visible = true;//делаем доступными первые каналы (chanNumb штук)
else
ChannNumb[i]->Visible = false;//остальные инактивируем
}
SAllChan->Enabled = bool(ftChan > 1);//инактивируем, если не используется
//устанавливаем множители для перевода времени в миллисекунды
for (i = 0; i < maxChannels; i++)
{
curntSigChannls[i]->XValues->Multiplier = (double)effDT / 1000;
csSpecPoint->XValues->Multiplier = (double)effDT / 1000;
PStart->exmplChannls[i]->XValues->Multiplier = (double)effDT / 1000;
}
}
Graphs->Show();
Resized(this);
}
//---------------------------------------------------------------------------
void TGraphs::ResetVisibility()
{
//запускаем прорисовку
__int32 i;
Label2->Caption = "из " + IntToStr(SigNumUpDwn->Max);
Label2->Visible = true;
ExpNotes->PIDates->Lines->Text = ExpNotes->pIDateString;//добавляем информацюи о файле
ClearGraphics();//затираем графики
//AddParamsPoints(trac *apSignals, __int32 apSigNum, __int32 *apIndex, short apExpType)
AddParamsPoints(gSignals, SigNumUpDwn->Max, gInd, experimentType);//рисуем все графики
//делаем видимыми кнопки редактирования файла
signalManager->Visible = true;
ShowMean->Visible = true;
expInfo->Visible = true;
ReCalculat->Visible = true;
SetExpAs->Visible = true;
ShowChanN->Visible = true;
//активируем кнопки пересохранения и экспортирования
gphSave->Enabled = true;
parametrExport->Enabled = true;
signalsExport->Enabled = true;
prntWin->Enabled = true;//"печать" окна
CrntSig->ReadOnly = false;
CrntSig->Text = "1";//выводим первый сигнал
SigNumUpDwn->Enabled = true;//разрешаем "листать" сигналы
SigNumUpDwn->Position = 1;//выводим первый сигнал
ShowSignal(SigNumUpDwn->Position);//выводим первый сигнал
}
//---------------------------------------------------------------------------
void TGraphs::FillParamTable()
{
//заполняем таблицу значениями параметров
__int32 i, j, k,
nrc,//количество заполняемых колонок
sch,//количестов второстепенных каналов (в одноканальном режиме)
numOfSig,//число записанных сигналов
shft1,//номер первого элемента для ampls и peakInds
shft2;//номер первого элемента для spans
float apt;
bool printMark;//есть ли метка для отображения
nrc = 5 + (5 * __int32(experimentType == 3));//количество заполняемых колонок
sch = (chanls - 1) * __int32(!multiCh);//количестов второстепенных каналов (в одноканальном режиме)
pValues->ColCount = nrc + sch + 1;//количество колонок в таблице по количеству параметров
if (experimentType == 3)
{
pValues->Cells[5][0] = "Na-ток, мВ";//первая амплитуда пресинаптического ответа (натриевый ток) (после синей, перед красной линии)
pValues->Cells[6][0] = "tNa, мкс";//длительность первого пика (натриевого тока, в микросекундах)
pValues->Cells[7][0] = "K-ток, мВ";//вторая амплитуда пресинаптического ответа (калиевый ток) (после синей, перед красной линии)
pValues->Cells[8][0] = "син зд, мкс";//синаптическая задержка или интервал... (в микросекундах)
pValues->Cells[9][0] = "st0, мкс";//время синаптического проведения (в микросекундах)
}
for (i = 1; i < sch; i++)
pValues->Cells[nrc + i - 1][0] = "канал" + IntToStr(i + 1) + ", мВ";//канал i
pValues->Cells[nrc + i - 1][0] = "заметки по ходу";//заметки по ходу эксперимента
numOfSig = SigNumUpDwn->Max;//количество сигналов в файле
pValues->RowCount = numOfSig + 1;//количество строк в таблице
printMark = false;//до обнаружения первой метки curR = false
for (j = 0; j < numOfSig; j++)//вписываем значения параметров в таблицу
{
for (i = 0; i < ExpNotes->addUMark->Tag; i++)//проверим дошли ли до точки, к которой привязана метка
{
if (ExpNotes->theMarker->pointOnGraph == j)//данная метка привязана к этому сигналу
{
printMark = true;//появилась метка: отображаем её
break;
}
ExpNotes->theMarker = ExpNotes->theMarker->nextM;//переходим к следующей метке
}
if (printMark)//есть метка для отображения
pValues->Cells[9 + maxChannels][j + 1] = ExpNotes->theMarker->textMark;//выводим заметки в крайнюю правую колонку
shft1 = (3 * ftChan * gInd[j]) + (3 * gRF[0]);//номер первого элемента для ampls и peakInds
shft2 = (5 * ftChan * gInd[j]) + (5 * gRF[0]);//номер первого элемента для spans
pValues->Cells[0][j + 1] = IntToStr(j + 1);//номер сигнала
pValues->Cells[1][j + 1] = FloatToStrF(gSignals[gInd[j]].appear, ffFixed, 6, 3);//время возникновения сигнала (синхроимпульса); в секундах от начала эксперимента
pValues->Cells[2][j + 1] = FloatToStrF((float)cPrm[0].ampls[shft1] * sampl2mV, ffFixed, 6, 3);//амплитуда основная - постсинаптическая (после красной линии)
pValues->Cells[3][j + 1] = IntToStr(cPrm[0].spans[shft2]);//время нарастания (микросекунды)
pValues->Cells[4][j + 1] = IntToStr(cPrm[0].spans[shft2 + 1]);//время спада (микросекунды)
if (experimentType == 3)
{
pValues->Cells[5][j + 1] = FloatToStrF((float)cPrm[0].ampls[shft1 + 1] * sampl2mV, ffFixed, 6, 3);//первая амплитуда пресинаптического ответа (натриевый ток) (после синей, перед красной линии)
pValues->Cells[6][j + 1] = IntToStr(cPrm[0].spans[shft2 + 2]);//длительность первого пика (натриевого тока, в микросекундах)
pValues->Cells[7][j + 1] = FloatToStrF((float)cPrm[0].ampls[shft1 + 2] * sampl2mV, ffFixed, 6, 3);//вторая амплитуда пресинаптического ответа (калиевый ток) (после синей, перед красной линии)
pValues->Cells[8][j + 1] = IntToStr(cPrm[0].spans[shft2 + 3]);//синаптическая задержка или интервал... (в микросекундах)
pValues->Cells[9][j + 1] = IntToStr(cPrm[0].spans[shft2 + 4]);//время синаптического проведения (в микросекундах)
}
for (i = 1; i < sch; i++)//выводим одиночные отсчёты на второстепенных каналах
{
k = recLen + i - 1;//номер нужного отсчёта
pValues->Cells[nrc + i - 1][j + 1] = FloatToStrF((float)gSignals[gInd[j]].s[k] * sampl2mV, ffFixed, 6, 3);
}
}
for (i = 2; i < pValues->ColCount; i++)
pValues->ColWidths[i] = (pValues->Cells[i][0].Length()) * 7;//устанавливаем ширину колонок
Resized(this);//задаём размеры таблицы и окна
}
//---------------------------------------------------------------------------
trac* TGraphs::CreatStructSignal(__int32 crNumOfS, __int32 crRecLen)
{
//создание массива с развёртками сигналов и их атрибутами (только в этом модуле)
/*
crNumOfS - запрашиваемое количество сигналов
crRecLen - запрашиваемая длина сигнала
*/
__int32 i, j,
fulChan,//количество каналов с полными развёртками
fullSigLen;//суммарная длина сигналов со всех каналов
trac *crStructSignal = new trac[crNumOfS];
fullSigLen = (crRecLen * ftChan) + (chanls - ftChan);//суммарная длина развёрток на всех каналах (отсчёты)
for (i = 0; i < crNumOfS; i++)
{
crStructSignal[i].s = new short[fullSigLen];//развёртки сигналов на всех каналах
for (j = 0; j < fullSigLen; j++)
crStructSignal[i].s[j] = 0;//зануляем значения массивов для сигналов
crStructSignal[i].appear = 0;//время возникновения сигнала (синхроимпульса); в секундах от начала эксперимента
}
cPrm = new sPr;//массивы с вычисляемыми параметрами сигналов
cPrm[0].ampls = new short[3 * crNumOfS * ftChan];//все пиковые значения (амплитуды)
//ampls[0] = amplPost - амплитуда основная - постсинаптическая (после красной линии)
//ampls[1] = ampl1NaPeak - первая амплитуда пресинаптического ответа (натриевый ток) (после синей, перед красной линии)
//ampls[2] = ampl2KPeak - вторая амплитуда пресинаптического ответа (калиевый ток) (после синей, перед красной линии)
cPrm[0].peakInds = new __int32[3 * crNumOfS * ftChan];//все номера отсчётов с пиковыми значениями
//peakInds[0] = indMaxPost - номер отсчёта с максимальным значением amplPost
//peakInds[1] = indMax1Na - номер отсчёта с максимальным значением amplPre1
//peakInds[2] = indMax2K - номер отсчёта с максимальным значением amplPre2
cPrm[0].spans = new __int32[5 * crNumOfS * ftChan];//все характерные времена (периоды, фазы, интервалы)
//spans[0] = riseT - время нарастания (микросекунды)
//spans[1] = fallT - время спада (микросекунды)
//spans[2] = tSynTrans - время синаптического проведения (в микросекундах)
//spans[3] = t1NaPeak - длительность первого пика (натриевого тока, в микросекундах)
//spans[4] = tDelay - синаптическая задержка или интервал... (в микросекундах)
for (j = 0; j < (3 * crNumOfS * ftChan); j++)
{
cPrm[0].ampls[j] = 0;//обнуляем
cPrm[0].peakInds[j] = 0;//обнуляем
}
for (j = 0; j < (5 * crNumOfS * ftChan); j++)
cPrm[0].spans[j] = 0;//обнуляем
return crStructSignal;
}
//---------------------------------------------------------------------------
void TGraphs::DeleteStructSignal(trac *delSignal, __int32 delNumOfS)
{
//удаление структуры с сигналами (только в этом модуле)
/*
delSignal - указатель на структуру с сигналами
delPrm - указатель на массив с вычислемыми параметрами сигналов
delNumOfS - количество сигналов, под которое изначально была зарезервирована память
*/
__int32 i;
for (i = 0; i < delNumOfS; i++)
delete[] delSignal[i].s;
delete[] delSignal; delSignal = NULL;
delete[] cPrm[0].ampls; cPrm[0].ampls = NULL;
delete[] cPrm[0].peakInds; cPrm[0].peakInds = NULL;
delete[] cPrm[0].spans; cPrm[0].spans = NULL;
delete[] cPrm; cPrm = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::gphOpenClick(TObject *Sender)
{
//открываем файл и начинаем рисовать всевозможные графики
//в этом модуле прописываю функции прорисовки графиков (к ним будут обращаться остальные модули)
__int32 i;
AnsiString extntFl;//расширение открываемого файла
if (OpenDlg->Execute())
{
Gists->Close();//закрытие окна с гистограммами
//удаляем всё из памяти
Experiment->DiscontinWrt->Tag = -1;//чтобы всё очистить
ClearMemor(this);//очистим память
plotFrom = 0;//рисуем сначала
//выделяем расширение открываемого файла
extntFl = OpenDlg->FileName.SubString(OpenDlg->FileName.Length() - 2, OpenDlg->FileName.Length());
//вызываем нужную функцию чтения файла
if (extntFl == "bin")
{
ConvertBinary(true);//переводим бинарные данные в текстовый вид(false) или в стандартный pra-формат(true)
}
else
{
if (extntFl == "pra")
ReadDataFile(this);//традиционный pra файл
else if (extntFl == "drr")
ReadLineData(this);//"линейный" drr файл
}
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::OnClosGraphs(TObject *Sender)
{
//при закрытии окна затираем данные
__int32 i;
ClearMemor(this);//очистим память
plotFrom = 0;//рисуем снача
//поменяем облик кнопок вызова графиков
for (i = 1; i < 9; i++)
allCharts[i]->Visible = false;//скрываем все чарты
_isfull = false;//нет развёрнутых графиков
Experiment->Ampl_inT->Font->Style = TFontStyles();//меняем облик кнопки
Experiment->Rise_inT->Font->Style = TFontStyles();//меняем облик кнопки
Experiment->Fall_inT->Font->Style = TFontStyles();//меняем облик кнопки
Experiment->NaAmpl_inT->Font->Style = TFontStyles();//меняем облик кнопки
Experiment->KAmpl_inT->Font->Style = TFontStyles();//меняем облик кнопки
Experiment->NaDur_inT->Font->Style = TFontStyles();//меняем облик кнопки
Experiment->SynDel_inT->Font->Style = TFontStyles();//меняем облик кнопки
Experiment->St0_inT->Font->Style = TFontStyles();//меняем облик кнопки
Experiment->plottedGrphs = 1;//обнуляем счётчик открытых графиков
Gists->GistsClear(this);//затираем гистограммы
CrntSig->ReadOnly = true;//запрещаем "листать" сигналы
}
//---------------------------------------------------------------------------
void TGraphs::ClearGraphics()
{
//затираем графики и очищаем таблицу
//если нажато дописать то грфики не затираем
__int32 i;
//очистить таблицу параметров
for (i = 1; i < pValues->RowCount; i++)
pValues->Rows[i]->Clear();
pValues->RowCount = 2;//уменьшаем до минимума количество строк в таблице
csSpecPoint->Clear();
for (i = 0; i < maxChannels; i++)
{
curntSigChannls[i]->Clear();//очищаем графики каналов
sigAmpls[i]->Clear();//очищаем графики амплитуд сигналов
allCharts[i]->UndoZoom();//отменяем увеличение, произведённое ранее
}
gRiseTsL->Clear();//график времём нарастания
gFallTsL->Clear();//график времён спада
gNaAmplsL->Clear();//амплитуда Na-тока
gNaDursL->Clear();//длительности Na-тока
gKAmplsL->Clear();//амплитуда K-тока
gSynDelsL->Clear();//синаптическая задержка
gSynTrnsL->Clear();//время синаптического проведения
curAmpl->Clear();//амплитуда выделенного сигнала (график-точка)
curRiseT->Clear();//время нарастания выделенного сигнала (график-точка)
curFallT->Clear();//время спада выделенного сигнала (график-точка)
curNaAmpl->Clear();//ампл Na-тока выделенного сигнала (график-точка)
curNaDur->Clear();//выделенный сигнал
curKAmpl->Clear();//выделенный сигнал
curSynDel->Clear();//выделенный сигнал
curSynTrns->Clear();//выделенный сигнал
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::ClearMemor(TObject *Sender)
{
//освобождаем память из под сигналов перед началом нового эксперимента
if (Experiment->DiscontinWrt->Tag != 1)//если записываем заново или открываем файл (не идёт дозапись файла)
{
Graphs->ClearGraphics();//затираем графики и очищаем таблицу
ExpNotes->DeleteMarkers();//удалем заметки
ExpNotes->nmInRec = 0;//количество меток записанных в предыдущих сеансах сбора данных (дозапись в существующий файл)
}
if (gSignals)
{
DeleteStructSignal(gSignals, SigNumUpDwn->Tag);//удаляем структуру с сигналами
gSignals = NULL;
}
if (gInd)
{
delete[] gInd;//удаляем массив индексов
gInd = NULL;
}
if (devExpParams_int)
{
delete[] devExpParams_int;//удаляем массив с параметрами устройства и эксперимента (__int32)
devExpParams_int = NULL;
}
if (devExpParams_float)
{
delete[] devExpParams_float;//удаляем массив с параметрами устройства и эксперимента (float)
devExpParams_float = NULL;
}
CrntSig->ReadOnly = true;
CrntSig->Text = "0";
SigNumUpDwn->Enabled = false;
Label2->Visible = false;
Graphs->Caption = "Графики";
//инактивируем кнопки редактирования файла
signalManager->Visible = false;
ShowMean->Visible = false;
expInfo->Visible = false;
ReCalculat->Visible = false;
SetExpAs->Visible = false;
ShowChanN->Visible = false;
//инактивируем кнопки пересохранения, экспортирования и т.д.
gphSave->Enabled = false;
parametrExport->Enabled = false;
signalsExport->Enabled = false;
prntWin->Enabled = false;//"печать" окна
}
//---------------------------------------------------------------------------
void TGraphs::ShowSignal(__int32 sn)
{
//выводим сигнал с заданным номером
/*
sn - номер сигнала (пользовательский [1, ..., N])
*/
__int32 i, z, k,
shft1,//номер первого элемента для ampls и peakInds
shft2,//номер первого элемента для spans
indBgn,//индекс - начало рисования
indSN;//номер сигнала в массиве индексов (реальный номер)
double *graphic;//массив с графиком
indSN = gInd[sn - 1];//определяем какой сигнал выводить
indBgn = gTimeBgn / effDT;//индекс - начало рисования
graphic = new double[recLen * (gRF[1] - gRF[0])];//массив с графиком
k = 0;
for (z = gRF[0]; z < gRF[1]; z++)
for (i = 0; i < recLen; i++)
{
graphic[k] = gSignals[indSN].s[(z * recLen) + i] * sampl2mV;
k++;
}
PlotCurrentSignal(graphic, indBgn);
//подсвечиваем параметры текущего сигнала на графиках
shft1 = (3 * ftChan * indSN) + (3 * 0);//номер первого элемента для ampls и peakInds
shft2 = (5 * ftChan * indSN) + (5 * 0);//номер первого элемента для spans
HighLightCrnt(&gSignals[indSN], shft1, shft2, experimentType, indBgn, sn - 1);
ExpNotes->addUMark->Text = "";//сначала затираем текст в окне для заметок
for (i = 0; i < ExpNotes->addUMark->Tag; i++)//если к сигналу прикреплена метка, то отобразим её в окне addUMark
{
if (((sn - 1) == ExpNotes->theMarker->pointOnGraph) && (ExpNotes->theMarker->chanN[gRF[0]]) &&
!SAllChan->Checked)//есть метка на сигнале (на канале)
{
ExpNotes->addUMark->Text = ExpNotes->theMarker->textMark;
break;
}
ExpNotes->theMarker = ExpNotes->theMarker->nextM;//переходим к следующей метке
}
delete[] graphic; graphic = NULL;//удаляем массив графика
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::sigNumUpDwnChangingEx(TObject *Sender,
bool &AllowChange, short NewValue, TUpDownDirection Direction)
{
//отображаем сигнал с заданным номером при любом изменение (программном или пользовательском)
//NewValue - введённый номер сигнала для пользователя (видимый номер)
if ((NewValue >= 1) && (NewValue <= SigNumUpDwn->Max))
{
CrntSig->Text = IntToStr(NewValue);//разрешаем внесённое изменение номера сигнала
CrntSig->Tag = NewValue;//копия номера сигнала для пользователя (нужна при редактировании меток)
ShowSignal(NewValue);//выводим сигнал с заданным номером
AllowChange = true;//разрешаем изменение
}
else
{
CrntSig->Text = IntToStr(SigNumUpDwn->Position);//оставляем прежнее значение
AllowChange = false;//не меняем
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::NextPres(TObject *Sender)
{
SigNumUpDwn->Position++;//следующий сигнал
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::PrevPres(TObject *Sender)
{
SigNumUpDwn->Position--;//предыдущий сигнал
}
//---------------------------------------------------------------------------
void TGraphs::HighLightCrnt(trac *hSig, __int32 shft1, __int32 shft2, short hExpT, __int32 hIndBgn, __int32 pGr)
{
//выделяем параметры текущего сигнала на графиках и подсвечиваем точки на графиках
/*
hSig - структура с подсвечиваемым сигналом
shft1 - номер первого элемента для ampls и peakInds
shft2 - номер первого элемента для spans
hExpT - тип эксперимента
hIndBgn - начальная для рисования точка сигнала
pGr - номер точки на графике
*/
__int32 i;
csSpecPoint->Clear();//сотрём амплитудные точки
curAmpl->Clear();//амплитуда
curRiseT->Clear();//время нарастания
curFallT->Clear();//время спада
//выделяем амплитудные точки
for (i = gRF[0]; i < gRF[1]; i++)
{
if (cPrm[0].peakInds[shft1 + (3 * i)] >= 0)
csSpecPoint->AddXY((cPrm[0].peakInds[shft1 + (3 * i)] - hIndBgn), (float)cPrm[0].ampls[shft1 + (3 * i)] * sampl2mV);
if (hExpT == 3)
{
csSpecPoint->AddXY((cPrm[0].peakInds[shft1 + (3 * i) + 1] - hIndBgn), (float)cPrm[0].ampls[shft1 + (3 * i) + 1] * sampl2mV);//выделяем точку амплитуды Na-тока
csSpecPoint->AddXY((cPrm[0].peakInds[shft1 + (3 * i) + 2] - hIndBgn), (float)cPrm[0].ampls[shft1 + (3 * i) + 2] * (-1) * sampl2mV);//выделяем точку амплитуды К-тока
}
//подсвечиваем выбранный сигнал на графиках
curAmpl->AddXY(hSig->appear + plotFrom, sigAmpls[i]->YValues->operator [](pGr));//(float)cPrm[0].ampls[shft1 + (3 * i)] * sampl2mV);
}
i = gRF[0];//первый отображаемый канал,
//подсвечиваем выбранный сигнал на графиках
AmplInT->Title->Text->Text = "амплитуда, " + FloatToStrF((float)cPrm[0].ampls[shft1 + (3 * i)] * sampl2mV, ffFixed, 6, 2) + " мВ";
curRiseT->AddXY(hSig->appear + plotFrom, gRiseTsL->YValues->operator [](pGr));//cPrm[0].spans[shft2]);
RiseTInT->Title->Text->Text = "время нарастания, " + IntToStr(cPrm[0].spans[shft2 + (5 * i)]) + " мкс";
curFallT->AddXY(hSig->appear + plotFrom, gFallTsL->YValues->operator [](pGr));//cPrm[0].spans[shft2 + 1]);
FallTInT->Title->Text->Text = "время спада, " + IntToStr(cPrm[0].spans[shft2 + (5 * i) + 1]) + " мкс";
if (hExpT == 3)
{
curNaAmpl->Clear();//амплитуда Na-тока
curNaAmpl->AddXY(hSig->appear + plotFrom, gNaAmplsL->YValues->operator [](pGr));//(float)cPrm[0].ampls[shft1 + 1] * sampl2mV);
NaAmplInT->Title->Text->Text = "Na-ток, " + FloatToStrF((float)cPrm[0].ampls[shft1 + (3 * i) + 1] * sampl2mV, ffFixed, 6, 2)+ " мВ";
curNaDur->Clear();//длительность Na-тока
curNaDur->AddXY(hSig->appear + plotFrom, gNaDursL->YValues->operator [](pGr));//cPrm[0].spans[shft2 + 2]);
NaDurInT->Title->Text->Text = "длительность Na-тока, " + IntToStr(cPrm[0].spans[shft2 + (5 * i) + 2]) + " мкс";
curKAmpl->Clear();//амплитуда К-тока
curKAmpl->AddXY(hSig->appear + plotFrom, gKAmplsL->YValues->operator [](pGr));//(float)cPrm[0].ampls[shft1 + 2] * sampl2mV);
KAmplInT->Title->Text->Text = "K-ток, " + FloatToStrF((float)cPrm[0].ampls[shft1 + (3 * i) + 2] * sampl2mV, ffFixed, 6, 2) + " мВ";
curSynDel->Clear();//синаптическая задержка
curSynDel->AddXY(hSig->appear + plotFrom, gSynDelsL->YValues->operator [](pGr));//cPrm[0].spans[shft2 + 3]);
SynDelInT->Title->Text->Text = "синаптическая задержка, " + IntToStr(cPrm[0].spans[shft2 + (5 * i) + 3]) + " мкс";
curSynTrns->Clear();//время синаптического проведения
curSynTrns->AddXY(hSig->appear + plotFrom, gSynTrnsL->YValues->operator [](pGr));//cPrm[0].spans[shft2 + 4]);
SynTrnsInT->Title->Text->Text = "синапт првд, " + IntToStr(cPrm[0].spans[shft2 + (5 * i) + 4]) + " мкс";
}
hSig = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::DeletSignalClick(TObject *Sender)
{
//реакция на нажатие кнопки удаления сигнала
__int32 i,
p;//номер отображаемого сигнала
p = SigNumUpDwn->Position - 1;//номер отображаемого сигнала
for (i = gRF[0]; i < gRF[1]; i++)//удаляем точку с графиков
sigAmpls[i]->Delete(p);
gRiseTsL->Delete(p);//удаляем точку с графиков
gFallTsL->Delete(p);
if (experimentType == 3)//удаляем точку с графиков
{
gNaAmplsL->Delete(p);
gNaDursL->Delete(p);
gKAmplsL->Delete(p);
gSynDelsL->Delete(p);
gSynTrnsL->Delete(p);
}
RemoveSignals(SigNumUpDwn->Position - 1);//собственно исключение сигнала из списка рассматриваемых
Label2->Caption = "из " + IntToStr(SigNumUpDwn->Max);//отображаем новое (оставшееся) количество сигналов
if ((p + 1) > SigNumUpDwn->Max)//удаление конечного сигнала
SigNumUpDwn->Position = SigNumUpDwn->Max;//поправка номера сигнала
else
ShowSignal(p + 1);//прорисовка сигнала (новый текущий сигнал)
}
//---------------------------------------------------------------------------
void TGraphs::RemoveSignals(__int32 sigToDel)
{
//удаляем индекс сигнала из массива индексов (если это разрешено)
/*
sigToDel - номер удаляемого сигнала (нумерация с нуля)
*/
__int32 i,
oldNum,//было сигналов
newNum;//останется сигналов
oldNum = SigNumUpDwn->Max;
newNum = oldNum - 1;
SigNumUpDwn->Max = newNum;//новое (оставшееся) количество сигналов
for (i = 0; i < ExpNotes->addUMark->Tag; i++)//если к удаляемому сигналу прикреплена метка, то удаляем и её
{
if (sigToDel == ExpNotes->theMarker->pointOnGraph)
ExpNotes->DeleteAMark(ExpNotes->theMarker);
ExpNotes->theMarker = ExpNotes->theMarker->nextM;//переходим к следующей метке
}
for (i = sigToDel; i < newNum; i++)//сдвигаем номера сигналов в массиве индексов влево
gInd[i] = gInd[i + 1];//сдвигаем номера сигналов в массиве индексов влево
for (i = 0; i < ExpNotes->addUMark->Tag; i++)//сдвигаем номера сигналов, к которым привязаны метки
{
if (ExpNotes->theMarker->pointOnGraph > sigToDel)
ExpNotes->theMarker->pointOnGraph--;//сдвигаем номера сигналов, к которым привязаны метки
ExpNotes->theMarker = ExpNotes->theMarker->nextM;//переходим к следующей метке
}
for (i = (sigToDel + 1); i < pValues->RowCount - 1; i++)
{
pValues->Rows[i] = pValues->Rows[i + 1];//перемещаме вверх
pValues->Cells[0][i] = IntToStr(i);//меняем номер сигнала
}
pValues->RowCount--;//удаляем строчку из таблицы
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::GphSaveClick(TObject *Sender)
{
//выбор имени файла для сохранения эксперимента
SaveDlg->Title = "Введите имя файла";
//SaveDlg->Options = TOptin << ofOverwritePrompt;//true;
SaveDlg->Filter = "*.pra|*.pra";
SaveDlg->DefaultExt = "pra";
SaveDlg->FileName = OpenDlg->FileName;//предлагаем сохранить под прежним именем
if (SaveDlg->Execute())
{
CrntSig->ReadOnly = true;//на время сохранения отменяем реакцию на изменение номера сигнала
SigNumUpDwn->Enabled = false;//также во время сохранения нельзя переключать сигналы
if (SaveExpDataToFile(experimentType, NULL, SigNumUpDwn->Max, false))
{
FillParamTable();//заполняем таблицу значениями параметров
ResetVisibility();//запускаем прорисовку
}
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::usersInfoClick(TObject *Sender)
{
//показываем информацию об эксперименте, введённую пользователем
//настроим элементы окна
ExpNotes->mainLinesLbl->Caption = "Общие сведения об эксперименте";
ExpNotes->usersNotes->Visible = true;//поле для пользовательских данных
ExpNotes->addUMark->Visible = true;//поле ввода заметок по ходу эксперимента
ExpNotes->addMarkLbl->Visible = true;//заметки-лэйбл
ExpNotes->PIDates->Visible = false;//поле данных о файле
ExpNotes->Show();//открываем окно блокнота
}
//---------------------------------------------------------------------------
void TGraphs::SetSeriesMultipliers()
{
//поменяем масштабные факторы для графиков в соответствии с указаниями пользователя
__int32 i,
cnt;
double fmValue;//первое или максимальное значение
cnt = sigAmpls[gRF[0]]->Count();//gAmplsL количество прорисованных сигналов
if (cnt >= 1)//на графиках есть точки
{
if (Experiment->shwAmpls->Checked)//показывать значения как есть
{
for (i = gRF[0]; i < gRF[1]; i++)
sigAmpls[i]->YValues->Multiplier = 1;//gAmplsL
for (i = 2; i < 9; i++)
allCharts[i]->Series[0]->YValues->Multiplier = 1;//нулевая серия - основной график
}
else if (Experiment->pCentFirstS->Checked)//показываем проценты величины первого сигнала
{
for (i = gRF[0]; i < gRF[1]; i++)
{
fmValue = fabs(sigAmpls[i]->YValues->operator [](0));//значение первого элемента
if (fmValue < 1)//максимальное значение очень мало
fmValue = 1;//заменяем единицей, чтобы избежать деления на ноль
sigAmpls[i]->YValues->Multiplier *= (double(100) / fmValue);//новый множитель
}
for (i = 2; i < 9; i++)
{
cnt = allCharts[i]->Series[0]->Count();//количество точек в данном графике
if (cnt >= 1)//график существует
{
fmValue = fabs(allCharts[i]->Series[0]->YValues->operator [](0));//значение первого элемента
if (fmValue < 1)//первое значение очень мало
fmValue = 1;//заменяем единицей, чтобы избежать деления на ноль
allCharts[i]->Series[0]->YValues->Multiplier *= (double(100) / fmValue);//новый множитель
}
}
}
else if (Experiment->pCentMax->Checked)//показываем проценты максимальной величины
{
for (i = gRF[0]; i < gRF[1]; i++)
{
fmValue = fabs(sigAmpls[i]->YValues->MaxValue);//максимальное значение в данном графике
if (fmValue < 1)//максимальное значение очень мало
fmValue = 1;//заменяем единицей, чтобы избежать деления на ноль
sigAmpls[i]->YValues->Multiplier *= (double(100) / fmValue);//новый множитель
}
for (i = 2; i < 9; i++)
{
cnt = allCharts[i]->Series[0]->Count();//количество точек в данном графике
if (cnt >= 1)//график существует
{
fmValue = fabs(allCharts[i]->Series[0]->YValues->MaxValue);//максимальное значение в данном графике
if (fmValue < 1)//максимальное значение очень мало
fmValue = 1;//заменяем единицей, чтобы избежать деления на ноль
allCharts[i]->Series[0]->YValues->Multiplier *= (double(100) / fmValue);//новый множитель
}
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::parametrExportClick(TObject *Sender)
{
//экспортирование параметров сигналов в текстовый файл (dat - формат)
FILE *stream;//поток вывода данных в файл
AnsiString bfr;//вспомогательная переменная
__int32 i, j,
shft1,//номер первого элемента для ampls и peakInds
shft2,//номер первого элемента для spans
rlSh,//исправленная длина сигнала (с учётом ПОСТ-времени, отсчёты)
bgnSigSh;//номер отсчёта, с которого начинается данный сигнал(с учётом многоканальности и ПОСТ-времени)
markers *printMark;//есть ли метка для отображения
//экспортируем параметры сигналов
SaveDlg->Title = "Экспорт параметров";//диалоговое сообщение
SaveDlg->Filter = "*.dat|*.dat";//фильтр отображения сигналов
SaveDlg->DefaultExt = "dat";//расширение по умолчанию
//по умолчанию вписываем в диалог имя открытого файла без расширения
bfr = OpenDlg->FileName;
bfr.Delete(bfr.Length() - 3, 4);//удаляем расширение
SaveDlg->FileName = bfr;
if (SaveDlg->Execute())
{
stream = fopen(SaveDlg->FileName.c_str(), "w");//создаём файл с параметрами сигналов
//вписываем названия измеряемых величин
fprintf(stream, "time\tamplPost\tArea\triseT\tfallT");
if (experimentType == 3)//внеклеточные: добавим спец параметры
fprintf(stream, "\tampl1Na\tampl2K\tt1Na\tsynDelay\tsynTr");
for (j = 0; ((j < (chanls - 1)) && !multiCh); j++)//если не многоканальный режим
{
bfr = "\tChannel";
bfr += IntToStr(j + 2);
fprintf(stream, bfr.c_str());
}
if (ExpNotes->addUMark->Tag > 0)//если есть заметки по ходу эксперимента
fprintf(stream, "\tMarks");
fprintf(stream,"\n");//закончили первую строку заголовка (названия измеряемых величин)
//вписываем размерности измеряемых величин
fprintf(stream, "sec\tmV\tmVms\tmks\tmks");//для параметров сигнала
if (experimentType == 3)//внеклеточные: добавим спец параметры
fprintf(stream, "\tmV\tmV\tmks\tmks\tmks");//для параметров сигнала
for (j = 0; ((j < (chanls - 1)) && !multiCh); j++)//если не многоканальный режим
fprintf(stream, "\tmV");//для данных со второстепенных каналов
if (ExpNotes->addUMark->Tag > 0)//если есть заметки по ходу эксперимента
fprintf(stream, "\tMarks");
fprintf(stream, "\n");//закончили вторую строку заголовка (размерности измеряемых величин)
//записываем собственно данные (значения параметров)
printMark = NULL;//до обнаружения первой метки printMark = false
rlSh = recLen - (gPostTime / effDT);//исправленная длина сигнала (с учётом ПОСТ-времени, отсчёты)
bgnSigSh = (gRF[0] * recLen) + (gPostTime / effDT);//номер отсчёта, с которого начинается данный сигнал(с учётом многоканальности и ПОСТ-времени)
for (i = 0; i < SigNumUpDwn->Max; i++)
{
shft1 = (3 * ftChan * gInd[i]) + (3 * gRF[0]);//номер первого элемента для ampls и peakInds
shft2 = (5 * ftChan * gInd[i]) + (5 * gRF[0]);//номер первого элемента для spans
fprintf(stream, "%8.3f\t%7.2f\t%7.2f\t%d\t%d",
gSignals[gInd[i]].appear,//время возникновения сигнала (в секундах от начала эксперимента)
(float)cPrm[0].ampls[shft1] * sampl2mV,//амплитуды
IntegralCalculate(&gSignals[gInd[i]], rlSh, sampl2mV * effDT, bgnSigSh),//"площадь" под сигналом
cPrm[0].spans[shft2],
cPrm[0].spans[shft2 + 1]);
if (experimentType == 3)//внеклеточные: добавим спец параметры
fprintf(stream, "\t%7.2f\t%7.2f\t%d\t%d\t%d",
(float)cPrm[0].ampls[shft1 + 1] * sampl2mV,
(float)cPrm[0].ampls[shft1 + 2] * sampl2mV,
cPrm[0].spans[shft2 + 2],
cPrm[0].spans[shft2 + 3],
cPrm[0].spans[shft2 + 4]);
if (!multiCh)//если не многоканальный режим
for (j = 0; j < (chanls - 1); j++)//вписываем данные со второстепенных каналов
fprintf(stream, "\t%7.2f", gSignals[gInd[i]].s[recLen + j] * sampl2mV);
if (ExpNotes->addUMark->Tag > 0)//если есть заметки по ходу эксперимента
{
//проверим дошли ли до точки, к которой привязана заметка
for (j = 0; j < ExpNotes->addUMark->Tag; j++)
{
if ((ExpNotes->theMarker->pointOnGraph == i) && (ExpNotes->theMarker->chanN[gRF[0]]))
{
printMark = ExpNotes->theMarker;//выводить текущую метку
break;
}
ExpNotes->theMarker = ExpNotes->theMarker->nextM;//переходим к следующей метке
}
if (printMark)
{
fprintf(stream, "\t");
fprintf(stream, printMark->textMark.c_str());//выводим заметки в крайнюю правую колонку
}
}
fprintf(stream, "\n");
}
fclose(stream);//закрываем файл (закрываем поток вывода данных в файл)
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::signalsExportClick(TObject *Sender)
{
//экспортирование развёрток сигналов в текстовый файл (dat - формат)
FILE *stream;//поток вывода данных в файл
AnsiString bfr;//вспомогательная переменная
__int32 i, j, z,
indBgn;//индекс - начало рисования
//экспорт сигналов
SaveDlg->Title = "Экспорт сигналов";//диалоговое сообщение
SaveDlg->Filter = "*.dat|*.dat";//фильтр отображения файлов
SaveDlg->DefaultExt = "dat";//расширение по умолчанию
//по умолчанию вписываем имя открытого файла в диалог
bfr = OpenDlg->FileName;
bfr.Delete(bfr.Length() - 3, 4);//удаляем расширение
SaveDlg->FileName = bfr;
if (SaveDlg->Execute())
{
stream = fopen(SaveDlg->FileName.c_str(), "w");
indBgn = gTimeBgn / effDT;//индекс - начало рисования
//вписываем названия величин
fprintf(stream, "time\t");
for (i = 0; i < SigNumUpDwn->Max; i++)
{
fprintf(stream, "s_%d\t", (i + 1));
for (z = 1; z < ftChan; z++)
fprintf(stream, "sub_%d\t", z);
}
fprintf(stream, "\n");
//вписываем размерности величин
fprintf(stream, "ms\t");
for (i = 0; i < ftChan * SigNumUpDwn->Max; i++)
fprintf(stream, "mV\t");
fprintf(stream, "\n");
//вписываем сигналы
for (j = indBgn; j < recLen; j++)//перебираем моменты времени (развёртки сигналов)
{
fprintf(stream, "%6.3f\t", (float)((j - indBgn) * effDT) / 1000);//время
for (i = 0; i < SigNumUpDwn->Max; i++)//перебираем сигналы и сохраняем в dat-файл
for (z = 0; z < ftChan; z++)
fprintf(stream, "%7.2f\t", ((float)gSignals[gInd[i]].s[(z * recLen) + j] * sampl2mV));//напряжение
fprintf(stream, "\n");
}
fclose(stream);//закрываем файл (поток вывода данных в файл)
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::ShowMeanClick(TObject *Sender)
{
//рисуем усреднённый сигнал
__int32 i, j, k,
fullSigLen,//суммарная длина развёрток на всех каналах (отсчёты)
indBgn,//индекс - начало рисования
count,//количество сигналов
*smIndex,//массив индексов
shft1,//номер первого элемента для ampls и peakInds
shft2;//номер первого элемента для spans
float average;//содержит усреднённый сигнал
trac *averSgnl;//содержит параметры среднего сигнала
sPr averPrm;//массив с параметрами среднего сигнала
double *graphic;//массив с графиком
fullSigLen = (recLen * ftChan) + (chanls - ftChan);//суммарная длина развёрток на всех каналах (отсчёты)
averSgnl = new trac[1];
averSgnl[0].s = new short[fullSigLen];
count = SigNumUpDwn->Max;//количество сигналов, по которым производим усреднение
for (j = 0; j < fullSigLen; j++)//перебор моментов времени (развёртки сигналов)
{
average = 0;//обнулим
for (i = 0; i < count; i++)//перебор сигналов
average += (float)gSignals[gInd[i]].s[j];
average /= count;//получаем среднее для данного момента времени
averSgnl[0].s[j] = short(floor(average + 0.5));//приводим к типу данных short
}
//создадим массив индексов
smIndex = new __int32[1];
smIndex[0] = 0;
averPrm.ampls = new short[3 * ftChan];//все пиковые значения (амплитуды)
averPrm.peakInds = new __int32[3 * ftChan];//все номера отсчётов с пиковыми значениями
averPrm.spans = new __int32[5 * ftChan];//все характерные времена (периоды, фазы, интервалы)
//вычислим параметры среднего сигнала
//Calculate(trac *sgnl, __int32 numOfS, short porog, __int32 preTime, __int32 postTime,
// __int32 *inds, short expT, bool newNull, short chn, sPr *avrP)
Calculate(averSgnl, 1, gPorog, gPreTime, gPostTime, smIndex, experimentType, true, &averPrm);
//выводим усреднённый сигнал
indBgn = gTimeBgn / effDT;//индекс - начало рисования
graphic = new double[recLen * (gRF[1] - gRF[0])];//массив с графиком
k = 0;
for (j = gRF[0]; j < gRF[1]; j++)
for (i = 0; i < recLen; i++)
{
graphic[k] = averSgnl[0].s[(j * recLen) + i] * sampl2mV;
k++;
}
PlotCurrentSignal(graphic, indBgn);
//выделяем амплитудные точки
csSpecPoint->Clear();//обозначим ключевые точки
for (i = gRF[0]; i < gRF[1]; i++)
{
shft1 = (3 * i);//номер первого элемента для ampls и peakInds
shft2 = (5 * i);//номер первого элемента для spans
if (averPrm.peakInds[shft1] >= 0)//положение амплитудной точки
csSpecPoint->AddXY((averPrm.peakInds[shft1] - indBgn), (float)averPrm.ampls[shft1] * sampl2mV);
if (experimentType == 3)
{
csSpecPoint->AddXY((averPrm.peakInds[shft1 + 1] - indBgn),//выделяем точку амплитуды Na-тока
(float)averPrm.ampls[shft1 + 1] * sampl2mV);
csSpecPoint->AddXY((averPrm.peakInds[shft1 + 2] - indBgn),//выделяем точку амплитуды К-тока
((float)averPrm.ampls[shft1 + 2] * (-1)) * sampl2mV);
}
}
shft1 = (3 * gRF[0]);//номер первого элемента для ampls и peakInds
shft2 = (5 * gRF[0]);//номер первого элемента для spans
//выведем значения параметров
curAmpl->Clear();//амплитуда
AmplInT->Title->Text->Text = "амплитуда, " + FloatToStrF((float)averPrm.ampls[shft1] * sampl2mV, ffFixed, 6, 2) + " мВ";
curRiseT->Clear();//время нарастания
RiseTInT->Title->Text->Text = "время нарастания, " + IntToStr(averPrm.spans[shft2]) + " мкс";
curFallT->Clear();//время спада
FallTInT->Title->Text->Text = "время спада, " + IntToStr(averPrm.spans[shft2 + 1]) + " мкс";
if (experimentType == 3)
{
curNaAmpl->Clear();//амплитуда Na-тока
NaAmplInT->Title->Text->Text = "Na-ток, " + FloatToStrF((float)averPrm.ampls[shft1 + 1] * sampl2mV, ffFixed, 6, 2)+ " мВ";
curNaDur->Clear();//длительность Na-тока
NaDurInT->Title->Text->Text = "длительность Na-тока, " + IntToStr(averPrm.spans[shft2 + 2]) + " мкс";
curKAmpl->Clear();//амплитуда К-тока
KAmplInT->Title->Text->Text = "K-ток, " + FloatToStrF((float)averPrm.ampls[shft1 + 2] * sampl2mV, ffFixed, 6, 2) + " мВ";
curSynDel->Clear();//синаптическая задержка
SynDelInT->Title->Text->Text = "синаптическая задержка, " + IntToStr(averPrm.spans[shft2 + 3]) + " мкс";
curSynTrns->Clear();//время синаптического проведения
SynTrnsInT->Title->Text->Text = "синапт првд, " + IntToStr(averPrm.spans[shft2 + 4]) + " мкс";
}
//удаление указателей
delete[] averSgnl[0].s; averSgnl[0].s = NULL;
delete[] averSgnl; averSgnl = NULL;
delete[] smIndex; smIndex = NULL;
delete[] averPrm.ampls; averPrm.ampls = NULL;
delete[] averPrm.peakInds; averPrm.peakInds = NULL;
delete[] averPrm.spans; averPrm.spans = NULL;
delete[] graphic; graphic = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::asIntracelClick(TObject *Sender)
{
//устанавливаем тип эксперимента
/* 1 - спонтанные
2 - вызвынные-внутриклеточные
3 - вызванные-внеклеточные
4 - вызванные + спонтанные */
experimentType = 2;//внутриклеточный (K-ток, Na-ток, синаптич. задержка и синапт. проведение теряются)
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::asExtracelClick(TObject *Sender)
{
//устанавливаем тип эксперимента
experimentType = 3;//внеклеточный (должны появиться дополнительные данные)
ReCalculatClick(this);//поэтому запускаем пересчёт
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::asMiniClick(TObject *Sender)
{
//устанавливаем тип эксперимента
experimentType = 1;//спонтанный (K-ток, Na-ток, синаптич. задержка и синапт. проведение теряются)
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::ReCalculatClick(TObject *Sender)
{
//пересчитаем параметры сигналов
__int32 i, j, k,
locPolar,//полярность локальная
curS,//номер текущего сигнала (в массиве gInd)
numOfS;
bool nlMins;//копия параметра PStart->nulMinus->Checked
double *grafik;//массив с графиками
if (PStart->Visible)
PStart->Close();//закроем окно предстарта
PStart->GetASignal->Caption = "Пересчёт";//меняем надпись кнопки
PStart->StartRec->Visible = false;//кнопка запуска эксперимента
PStart->CloseWin->Visible = false;//кнопка закрытия окно предстарта
PStart->ExpInfo->Visible = false;//кнока вызова окна ввода пользовательской информации
ReCalculat->Tag = experimentType;//передаём тип эксперимента в PStart
PStart->GetASignal->OnClick = PStart->ReCalClick;//меняем функцию кнопки
PStart->SetControlVis(experimentType);//делаем видимыми нужные органы управления и убираем ненужные
PStart->Invert->Checked = false;//изменение статуса индикатора инвертирования
PStart->Invert->OnClick = PStart->InvertClick;//изменение реакции на смену индикатора
numOfS = SigNumUpDwn->Max;//общее количество доступных сигналов
curS = gInd[(SigNumUpDwn->Position - 1)];//номер текущего сигнала (в массиве gInd)
PStart->Caption = "Пересчёт параметров";
//создаём график
grafik = new double[recLen * (gRF[1] - gRF[0])];//массив с графиками
k = 0;
for (j = gRF[0]; j < gRF[1]; j++)
for (i = 0; i < recLen; i++)
{
grafik[k] = gSignals[curS].s[(j * recLen) + i] * sampl2mV;
k++;
}
//PlotStandardSignal(double *sData, __int32 sRecLen, __int32 sEffDT, __int32 sIndBgn)
PStart->PlotStandardSignal(grafik, recLen, effDT, 0);//рисуем текущий сигнал для наглядности
PStart->PreTime->Text = IntToStr(devExpParams_int[8]);//пре-время
PStart->PostTime->Text = IntToStr(devExpParams_int[9]);//пост-время
PStart->Porog->Text = IntToStr(devExpParams_int[10]);//порог
PStart->timeOfDrawBgn = 0;//(float)(gTimeBgn);//передаём значение индекса-начала в модуль PStart
PStart->RefreshLines(effDT);//перерисовать линии
PStart->Invert->Checked = false;//не инвертировать
PStart->NulMinus->Checked = false;//не вычетать ноль-линию
if (PStart->ShowModal() == mrOk)//если нажат "Пересчёт"
{
//после закрытия окна и произойдёт пересчёт, если был нажат "Пересчёт"
gPreTime = StrToInt(PStart->PreTime->Text);
gPostTime = StrToInt(PStart->PostTime->Text);
gPorog = short((float)StrToInt(PStart->Porog->Text) / sampl2mV);//пороговое напряжение (отсчёты)
//если выставлена галочка invert, то предварительно инвертируем сигналы
if (PStart->Invert->Checked)
for (j = gRF[0]; j < gRF[1]; j++)
for (i = 0; i < recLen; i++)
gSignals[gInd[j]].s[i] = (-1) * gSignals[gInd[j]].s[i];
//если выбрано "вычетать ноль-линию", то будет расчитана ноль-линия для каждого сигнала отдельно
//newNull = PStart->nulMinus->Chacked;//указываем, что запускается ПЕРЕсчёт параметров
//собственно пересчёт параметров с новыми настройками
//Calculate(trac *sgnl, __int32 numOfS, short porog, __int32 preTime, __int32 postTime,
// __int32 *inds, short expT, bool newNull, short chn, sPr *avrP)
Calculate(gSignals, numOfS, gPorog, gPreTime, gPostTime, gInd, experimentType, PStart->NulMinus->Checked, NULL);
//===================================
//запомним новые настройки
devExpParams_int[8] = StrToInt(PStart->PreTime->Text);
devExpParams_int[9] = StrToInt(PStart->PostTime->Text);
devExpParams_int[10] = StrToInt(PStart->Porog->Text);
//вычисляем первую точку рисования сигналов
gTimeBgn = 0;
if (experimentType == 2)
gTimeBgn = gPostTime;
else if (experimentType == 3)
gTimeBgn = gPreTime;
ClearGraphics();//затираем графики
FillParamTable();//перезаполняем таблицу
//AddParamsPoints(trac *apSignals, __int32 apSigNum, __int32 *apIndex, short apExpType)
AddParamsPoints(gSignals, SigNumUpDwn->Max, gInd, experimentType);//перерисуем все графики
CopyRefSignal_forGists();//расчёт и построение гистограмм с новыми параметрами
ShowSignal(SigNumUpDwn->Position);//выводим тот же сигнал, который был нарисован до пересчёта
}
//восстанавливаем функции "инвертирования"
PStart->Invert->Checked = false;//PStart->invert->Visible = true;
PStart->Invert->OnClick = NULL;//изменение реакции на смену индикатора
PStart->GetASignal->OnClick = PStart->GetASignalClick;//восстанавливаем функцию
//восстанавливаем вид окна
PStart->GetASignal->Caption = "Пример сигнала";//восстанавливаем надпись кнопки
PStart->StartRec->Visible = true;//кнопка запуска эксперимента
PStart->CloseWin->Visible = true;//кнопка закрытия окно предстарта
PStart->ExpInfo->Visible = true;//кнока вызова окна ввода пользовательской информации
delete[] grafik; grafik = NULL;
}
//---------------------------------------------------------------------------
void TGraphs::ReplotExamplRecalc()
{
//перерисовка эталонного сигнала при прересчёте параметров сигналов
__int32 i, j, k,
curS;//номер текущего сигнала
double *grafik,//единый массив с сигналами со всех каналов
locPolar;//полярность
curS = gInd[(SigNumUpDwn->Position - 1)];
locPolar = 1;
if (PStart->Invert->Checked)
locPolar = (-1);
grafik = new double[recLen * (gRF[1] - gRF[0])];//массив с графиками
k = 0;
for (j = gRF[0]; j < gRF[1]; j++)
for (i = 0; i < recLen; i++)
{
grafik[k] = locPolar * gSignals[curS].s[(j * recLen) + i] * sampl2mV;
k++;
}
//PlotStandardSignal(double *sData, __int32 sRecLen, __int32 sEffDT, __int32 sIndBgn)
PStart->PlotStandardSignal(grafik, recLen, effDT, 0);//рисуем текущий сигнал для наглядности
delete[] grafik; grafik = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::GraphChartDblClick(TObject *Sender)
{
//разворачиваем чарт на всю ширину окна графиков
__int32 i;
TChart *theChart;//указатель на обрабатываемый чарт
_isfull = !_isfull;//развёрнут ли какой-нибудь график
theChart = (TChart*)Sender;//обрабатываемый чарт
theChart->AllowZoom = false;//запрещаем увеличивать
if (_isfull)
{
theChart->Width = Graphs->Width - 7;//новая ширина (на всё окно)
theChart->Height = Graphs->Height - 50;//новая высота (на всё окно)
theChart->Left = 0;//левый край
theChart->Top = 0;//верхний край
for (i = 0; i < 9; i++)
if (i != theChart->Tag)
{
mask[i] = allCharts[i]->Visible;//запоминаем параметр
allCharts[i]->Visible = false;//делаем невидимыми все остальные графики
}
}
else
{
for (i = 0; i < 9; i++)
if (i != theChart->Tag)
allCharts[i]->Visible = mask[i];//восстанавливаем значение параметра
Resized(this);//перерисовываем графики
}
theChart->AllowZoom = true;//разрешаем увеличивать
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::Resized(TObject *Sender)
{
__int32 numOfgraphs = 0, // количество высвечиваемых графиков
i,
winWidth,//ширина окна графиков
winHeight,//высота окна графиков
//индексы в массиве ссылок на видимые графики (чарты, не более пяти)
iVCh[5] = {0, 0, 0, 0, 0};
if (pValues->Visible)
{
//подгоняем размеры таблицы
pValues->Top = 0;
pValues->Left = 0;
winWidth = 0;
//winHeight = 0;
for (i = 0; i < pValues->ColCount; i++)
winWidth += pValues->ColWidths[i];
if (winWidth < 415)
winWidth = 415;
pValues->Width = winWidth + 30;//плюс ширина scrollBar
Graphs->Width = pValues->Width + 8;
pValues->Height = Graphs->Height - 58;
}
else
{
//копируем ссылки на графики (чарты), которые видны
for (i = 0; i < 9; i++)
if (allCharts[i]->Visible)
{
iVCh[numOfgraphs] = i;
numOfgraphs++;
}
winWidth = Graphs->Width;
if ((numOfgraphs == 2) || (numOfgraphs == 4))
{
if ((winWidth / 2) < 235)
Graphs->Width = 235 * 2;
}
if (numOfgraphs == 3)
{
if ((winWidth / 3) < 235)
Graphs->Width = 235 * 3;
}
winWidth = Graphs->Width - 7;
winHeight = Graphs->Height - 50;
//меняем размер чартов
if (numOfgraphs == 1)
{
i = 0;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = 0;
allCharts[iVCh[i]]->Width = winWidth;
allCharts[iVCh[i]]->Height = winHeight;
}
if (numOfgraphs == 2)
{
i = 0;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = 0;
allCharts[iVCh[i]]->Width = winWidth/2;
allCharts[iVCh[i]]->Height = winHeight;
i = 1;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = winWidth/2;
allCharts[iVCh[i]]->Width = winWidth/2;
allCharts[iVCh[i]]->Height = winHeight;
}
if (numOfgraphs == 3)
{
i = 0;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = 0;
allCharts[iVCh[i]]->Width = winWidth/3;
allCharts[iVCh[i]]->Height = winHeight;
i = 1;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = winWidth/3;
allCharts[iVCh[i]]->Width = winWidth/3;
allCharts[iVCh[i]]->Height = winHeight;
i = 2;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = 2 * (winWidth/3);
allCharts[iVCh[i]]->Width = winWidth/3;
allCharts[iVCh[i]]->Height = winHeight;
}
if (numOfgraphs == 4)
{
i = 0;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = 0;
allCharts[iVCh[i]]->Width = winWidth/2;
allCharts[iVCh[i]]->Height = winHeight/2;
i = 1;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = winWidth/2;
allCharts[iVCh[i]]->Width = winWidth/2;
allCharts[iVCh[i]]->Height = winHeight/2;
i = 2;
allCharts[iVCh[i]]->Top = winHeight/2;
allCharts[iVCh[i]]->Left = 0;
allCharts[iVCh[i]]->Width = winWidth/2;
allCharts[iVCh[i]]->Height = winHeight/2;
i = 3;
allCharts[iVCh[i]]->Top = winHeight/2;
allCharts[iVCh[i]]->Left = winWidth/2;
allCharts[iVCh[i]]->Width = winWidth/2;
allCharts[iVCh[i]]->Height = winHeight/2;
}
if (numOfgraphs == 5)
{
//SignalTrack->Visible = true - виден всегда
i = 0;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = 0;
allCharts[iVCh[i]]->Width = winWidth/3;
allCharts[iVCh[i]]->Height = winHeight/2;
//AmplInT
i = 1;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = winWidth/3;
allCharts[iVCh[i]]->Width = winWidth/3;
allCharts[iVCh[i]]->Height = winHeight/2;
//NaAmplInT
i = 2;
allCharts[iVCh[i]]->Top = 0;
allCharts[iVCh[i]]->Left = 2 * (winWidth/3);
allCharts[iVCh[i]]->Width = winWidth/3;
allCharts[iVCh[i]]->Height = winHeight/2;
//RiseTInT
i = 3;
allCharts[iVCh[i]]->Top = winHeight/2;
allCharts[iVCh[i]]->Left = 0;
allCharts[iVCh[i]]->Width = winWidth/2;
allCharts[iVCh[i]]->Height = winHeight/2;
//FallTInT
i = 4;
allCharts[iVCh[i]]->Top = winHeight/2;
allCharts[iVCh[i]]->Left = winWidth/2;
allCharts[iVCh[i]]->Width = winWidth/2;
allCharts[iVCh[i]]->Height = winHeight/2;
}
}
}
//---------------------------------------------------------------------------
void TGraphs::PlotCurrentSignal(double *pcsData, __int32 pcsIndBgn)
{
//рисуем быстро текущий (или один из последних) сигнал во время сбора данных
/*
pcsData - массив с графиками
pcsIndBgn - начальный отсчёт сигнала
*/
__int32 i;
SignalTrack->AutoRepaint = false;//отключаем автопрорисовку для ускорения процесса рисования
for (i = gRF[0]; i < gRF[1]; i++)//рисуем быстро все каналы
{
curntSigChannls[i]->Clear();//затираем старый график
curntSigChannls[i]->AddArray(&pcsData[pcsIndBgn + ((i - gRF[0]) * recLen)], (recLen - pcsIndBgn) - 1);
}
SignalTrack->BottomAxis->SetMinMax(0, double((recLen - pcsIndBgn) * effDT) / 1000);
SignalTrack->AutoRepaint = true;//возвращаем автопрорисовку, чтобы график обновился
SignalTrack->Repaint();//Refresh();//обновляем чарт
pcsData = NULL;
}
//---------------------------------------------------------------------------
void TGraphs::AddParamsPoints(trac *apSignals, __int32 apSigNum, __int32 *apIndex, short apExpType)
{
//добавим точки на графики параметров
/*
apSignals - структура с сигналами
apSigNum - количество обрабатываемых сигналов
apIndex - массив индексов
apAmplCoeff - коэффициент пересчёта амплитуд
apExpType - тип эксперимента
*/
__int32 i, j,
nrc,//количество обновляемых чартов
shft1,//номер первого элемента для ampls и peakInds
shft2;//номер первого элемента для spans
//подрисовываем графики параметров
nrc = 4 + (5 * __int32(apExpType == 3));//количество обновляемых чартов
for (i = 1; i < nrc; i++)
allCharts[i]->AutoRepaint = false;//отключаем автопрорисовку всех чартов, кроме SignalTrack
for (j = 0; j < apSigNum; j++) //apSigNum - 1
{
for (i = gRF[0]; i < gRF[1]; i++)
{
shft1 = (3 * ftChan * apIndex[j]) + (3 * i);//номер первого элемента для ampls и peakInds
shft2 = (5 * ftChan * apIndex[j]) + (5 * i);//номер первого элемента для spans
sigAmpls[i]->AddXY(apSignals[apIndex[j]].appear + plotFrom, cPrm[0].ampls[shft1] * sampl2mV);
}
shft1 = (3 * ftChan * apIndex[j]) + (3 * gRF[0]);//номер первого элемента для ampls и peakInds
shft2 = (5 * ftChan * apIndex[j]) + (5 * gRF[0]);//номер первого элемента для spans
gRiseTsL->AddXY(apSignals[apIndex[j]].appear + plotFrom, cPrm[0].spans[shft2]);
gFallTsL->AddXY(apSignals[apIndex[j]].appear + plotFrom, cPrm[0].spans[shft2 + 1]);
if (apExpType == 3)
{
gNaAmplsL->AddXY(apSignals[apIndex[j]].appear + plotFrom, cPrm[0].ampls[shft1 + 1] * sampl2mV);
gNaDursL->AddXY(apSignals[apIndex[j]].appear + plotFrom, cPrm[0].spans[shft2 + 2]);
gKAmplsL->AddXY(apSignals[apIndex[j]].appear + plotFrom, cPrm[0].ampls[shft1 + 2] * sampl2mV);
gSynDelsL->AddXY(apSignals[apIndex[j]].appear + plotFrom, cPrm[0].spans[shft2 + 3]);
gSynTrnsL->AddXY(apSignals[apIndex[j]].appear + plotFrom, cPrm[0].spans[shft2 + 4]);
}
}
for (i = 1; i < nrc; i++)
{
allCharts[i]->AutoRepaint = true;//восстанавливаем автопрорисовку чартов
allCharts[i]->Repaint();//Refresh();//обновляем чарт
}
SetSeriesMultipliers();//поменяем масштабные факторы для графиков
apSignals = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::ChartsClickSeries(TCustomChart *Sender, TChartSeries *Series,
int ValueIndex, TMouseButton Button, TShiftState Shift, int X, int Y)
{
//кликнул по графику основных амплитуд
SigNumUpDwn->Position = ValueIndex + 1;//выведем соответствующий сигнал
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::pValuesSelectCell(TObject *Sender, int ACol, int ARow, bool &CanSelect)
{
//при выделении какой-либо клетки меняем номер текущего сигнала
SigNumUpDwn->Position = ARow;
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::selAllClick(TObject *Sender)
{
//выделить все видимые элементы таблицы
// pValues->Selection.Left = 2;
// pValues->Selection.Right = 2;
// pValues->Selection.Top = 4;
// pValues->Cols->
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::selCopyClick(TObject *Sender)
{
//копируем выделенную область таблицы (в буфер обмена)
__int32 i, j,
colL, colR,
rowT, rowB;
AnsiString s;
HGLOBAL hgBuffer;
char* chBuffer;
colL = pValues->Selection.Left;
colR = pValues->Selection.Right;
rowT = pValues->Selection.Top;
rowB = pValues->Selection.Bottom;
//собственно копирование
s = "";
for (i = rowT; i <= rowB; i++)
{
for (j = colL; j <= colR; j++)
{
s += pValues->Cells[j][i];
s += "\t";
}
s += "\r\n";
}
if (OpenClipboard(NULL))//открываем буфер обмена
{
EmptyClipboard();//очищаем буфер
hgBuffer = GlobalAlloc(GMEM_DDESHARE, s.Length() + 1);//выделяем память
chBuffer = (char*)GlobalLock(hgBuffer);//блокируем память
strcpy(chBuffer, LPCSTR(s.c_str()));//копируем текст по адресу chBuffer
GlobalUnlock(hgBuffer);//разблокируем память
SetClipboardData(CF_TEXT, hgBuffer);//помещаем текст в буфер обмена
CloseClipboard(); //закрываем буфер обмена
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::amplInTAfterDraw(TObject *Sender)
{
//рисуем метки по ходу эксперимента
__int32 i, j,
pCount,//количество точек на графике
pnOnGrph,//номер точки на графике
x0, x1,//х - координата для надписи
y0, y1,//y - координата для надписи
fH,//высота надписи
fW;//ширина надписи
if (showMarks->Checked)
for (i = 0; i < ExpNotes->addUMark->Tag; i++)
{
for (j = gRF[0]; j < gRF[1]; j++)//j - номер канала который сейчас просматриваем
{
pCount = sigAmpls[j]->Count();//количество точек на графике
if (ExpNotes->theMarker->chanN[j])//видна ли метка на данном канале
{
pnOnGrph = ExpNotes->theMarker->pointOnGraph;//номер точки на графике
if ((pnOnGrph < pCount) && (pnOnGrph >= 0))//сигнал с данным номером есть на графике
{
x0 = sigAmpls[j]->CalcXPos(pnOnGrph);//x0 координата надписи
y0 = sigAmpls[j]->CalcYPos(pnOnGrph);//y0 координата надписи
fH = AmplInT->Canvas->TextHeight(ExpNotes->theMarker->textMark);//высота надписи
fW = __int32((float)AmplInT->Canvas->TextWidth(ExpNotes->theMarker->textMark) * 1.15);//ширина надписи
x1 = x0 - floor(fW / 2);//x1 координата надписи
y1 = y0 - (2 * fH);//y1 координата надписи
AmplInT->Canvas->Rectangle(x1, y1, x1 + fW, y1 + fH);//рамка для надписи
AmplInT->Canvas->TextOutA(x1 + 2, y1, ExpNotes->theMarker->textMark);//сама надпись
AmplInT->Canvas->Line(x0, y0 - fH, x0, y0);//стрелка (указывает на точку, к которой привязана надпись)
}
}
}
ExpNotes->theMarker = ExpNotes->theMarker->nextM;//переходим к следующей метке
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::showMarksClick(TObject *Sender)
{
//отображать ли "заметки по ходу эксперимента"
showMarks->Checked = !showMarks->Checked;//
AmplInT->Refresh();//перерисуем или затрём метки
}
//---------------------------------------------------------------------------
void TGraphs::CopyRefSignal_forGists()
{
//копируем ссылку на структуру с сигналами и передаём её в модуль построения гистограмм
if ((gSignals) && (SigNumUpDwn->Max > 1))//количество сигналов больше одного
Gists->GistsRefresh(-1);
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::CrntSigKeyUp(TObject *Sender, WORD &Key, TShiftState Shift)
{
//реакция на смену номера пользователем
if (((Key >= '0') && (Key <= '9')) || (Key != '\b'))//проверим допустимость введённых символов
SigNumUpDwn->Position = StrToInt(CrntSig->Text);//
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::CrntSigKeyPress(TObject *Sender, char &Key)
{
//проверка допустимости введения символа в поле номера сигнала
if (((Key < '0') || (Key > '9')) && (Key != '\b'))//проверим допустимость введённых символов
Key = '\0';//зануляем некорректный символ
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::CrntSigKeyDown(TObject *Sender, WORD &Key, TShiftState Shift)
{
//отслеживаем нажатие стрелок (для индикатора номера сигнала)
if (!CrntSig->ReadOnly)//
{
if (Key == VK_UP)//кнопка "вниз" - предыдущий сигнал
SigNumUpDwn->Position--;//
else if (Key == VK_DOWN)//кнопка "вверх" - следующий сигнал
SigNumUpDwn->Position++;//
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::remGrpSigsClick(TObject *Sender)
{
//удаление заданной группы сигналов
if (gSignals)//сигналы существуют
{
ChoosDlg->setsForNumbersChs();//настраиваем окно диалога для ввода номеров сигналов (удаляемых)
ChoosDlg->sav = false;//задано удаление группы сигналов
ChoosDlg->Caption = "Удаление группы сигналов";
ChoosDlg->ShowModal();
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::saveGrpSigsClick(TObject *Sender)
{
//сохранение заданной группы сигналов
if (gSignals)
{
ChoosDlg->setsForNumbersChs();//настраиваем окно диалога для ввода номеров сигналов (сохраняемых)
ChoosDlg->sav = true;//задано сохранение группы сигналов
ChoosDlg->Caption = "Сохранение группы сигналов";
ChoosDlg->ShowModal();
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::dividGrpsClick(TObject *Sender)
{
//разбиение массива данных на группы по nInGrp сигналов
if (gSignals)
{
ChoosDlg->setsForNOfGrp();//настраиваем окно диалога для ввода числа сигналов в группе (nInGrp)
ChoosDlg->sav = true;//будем пересохранять текущий файл
ChoosDlg->ShowModal();//вызываем диалог для ввода размера групп сигналов
}
}
//---------------------------------------------------------------------------
void TGraphs::RemovEnteredNumbers(__int32 *removIndex, __int32 count)
{
//сохранение или удаление группы сигналов
/*
svRmIndex - указатель на массив с введёнными номерами
count - количество удаляемых сигналов
*/
__int32 i, j;
//удаляем все указанные сигналы
for (i = 0; i < count; i++)
RemoveSignals(removIndex[i]);//собственно исключение сигнала из списка рассматриваемых
if (ChoosDlg->sav)//задано сохранение оставшихся файлов
GphSaveClick(this);//сохраняем группу сигналов с указанным именем
else
ResetVisibility();//запускаем прорисовку
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::PrintWinClick(TObject *Sender)
{
//распечатать всё, что изображено в окне графиков
__int32 i;
Graphics::TBitmap *frmImg;
AnsiString imgFlNm;
frmImg = Graphs->GetFormImage();
imgFlNm = OpenDlg->FileName;
imgFlNm.Delete(imgFlNm.Length() - 3, 4);
imgFlNm += "_1.bmp";
i = 2;
while (FileExists(imgFlNm))
{
imgFlNm.Delete(imgFlNm.Length() - 5, 6);
imgFlNm += "_" + IntToStr(i) + ".bmp";
i++;
}
frmImg->SaveToFile(imgFlNm);//сохранение файла
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::SignalTrackMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y)
{
//подрисуем значение напряжения в данной точке
__int32 cp,//номер точки графика, на которую указали
x0, x1,//х - координата для надписи
y0, y1,//y - координата для надписи
fH,//высота надписи
fW;//ширина надписи
float gX, gY;//значения координат на графике
AnsiString voltText;//надпись с напряжением в данной точке
TRect rc;
if ((Button == 0) && gSignals && (curntSigChannls[gRF[0]]->Count() > 0))//если нажата правая кнопка мыши и графики нарисованы
{
gX = curntSigChannls[gRF[0]]->XScreenToValue(X);//х-коодината кликнутой точки
//найдём номер точки графика, которая ближе остальных к кликнутой
x0 = 0;//левая граница
x1 = curntSigChannls[gRF[0]]->XValues->Count() - 1;//правая граница
cp = x0 + floor((x1 - x0) / 2);//затравочный номер точки графика
while ((x1 - x0) > 3)
{
gY = (float)cp * effDT * 1e-3;//х-координата точки графика
if (gY < gX)
x0 = cp;
else
x1 = cp;
cp = x0 + floor((x1 - x0) / 2);//уточнённый номер точки графика
}
cp = x0;//номер точки графика, на которую указали (Locate(graphX) - требует точного соответствия)
if (cp >= 0)
{
x0 = curntSigChannls[gRF[0]]->CalcXPos(cp);//точка прикрепления надписи на графике
y0 = curntSigChannls[gRF[0]]->CalcYPos(cp);//точка прикрепления надписи на графике
gY = curntSigChannls[gRF[0]]->YValues->operator [](cp);//(float)gSignals[i].s[indBgn + cp] * sampl2mV;//с поправкой на gIndBgn
voltText = "x=" + FloatToStrF(gX, ffFixed, 6, 2) + "; "
+ "y=" + FloatToStrF(gY, ffFixed, 6, 2);
//задаём облик надписи
SignalTrack->Canvas->Pen->Width = 2;
SignalTrack->Canvas->Pen->Color = clGreen;
SignalTrack->Canvas->Brush->Color = clWhite;
SignalTrack->Canvas->Font->Size = 10;
SignalTrack->Canvas->Font->Style = TFontStyles() << fsBold;
SignalTrack->Canvas->Font->Name = "Arial";
//размеры надписи
fH = (__int32)((float)SignalTrack->Canvas->TextHeight(voltText) * 1.15);
fW = (__int32)((float)SignalTrack->Canvas->TextWidth(voltText) * 1.05);
x1 = x0 - floor(fW / 2);
y1 = y0 - 2 * fH;
rc.left = x1 + 1; rc.top = y1 + 1;
rc.right = x1 + fW - 2; rc.Bottom = y1 + fH - 2;
SignalTrack->Canvas->Rectangle(x1, y1, x1 + fW, y1 + fH);//рамка для надписи
SignalTrack->Canvas->FillRect(rc);
SignalTrack->Canvas->TextOutA(x1 + 1, y1, voltText);//сама надпись
SignalTrack->Canvas->Line(x0, y0 - fH, x0, y0);//стрелка (указывает на точку, к которой привязана надпись)
}
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::expParamsClick(TObject *Sender)
{
//показать информацию об эксперименте
//настроим элементы окна
ExpNotes->mainLinesLbl->Caption = "Информация о файле";
ExpNotes->PIDates->Visible = true;//поле данных о файле
ExpNotes->usersNotes->Visible = false;//поле для пользовательских данных
ExpNotes->addUMark->Visible = false;//поле ввода заметок по ходу эксперимента
ExpNotes->addMarkLbl->Visible = false;//заметки-лэйбл
ExpNotes->PIDates->Top = ExpNotes->usersNotes->Top;
ExpNotes->PIDates->Left = ExpNotes->usersNotes->Left;
ExpNotes->PIDates->Width = ExpNotes->usersNotes->Width;
ExpNotes->PIDates->Height = ExpNotes->addUMark->Top + ExpNotes->addUMark->Height;
ExpNotes->Show();
}
//---------------------------------------------------------------------------
void TGraphs::ConvertBinary(bool cTyp)
{
//чтение бинарного файлы с результатами непрерывной записи всего подряд (осциллограф)
//перевод данных в текстовый вид
/*
cTyp - тип конвертации (false - в текст, true - в pra-формат)
*/
HANDLE ContinRecFile;//хэндл файла, из которого читаем данные
FILE *stream;//поток вывода информации в файл
__int32 i, j, k, t,
recStep,//шаг записи
numOfSig,//число записанных сигналов
flSize,//размер файла
totSigNum,//предельное количество сигналов
backLen,//время назад (отсчёты)
realSigNum,//количество обнаруженных сигналов
leadChan,//ведущий канал (основной сигнал)
nGain;//коэффициент усиления
short *dataBlock,//блок с одиночыми отсчётами от каждого канала
*data,//массив с данными для всех каналов
**dataCh,//массив с данными поканально
polarity;//полярность
AnsiString fileParametr,//общий коментарий
convertedData;//имя файла с конвертированными данными
char *pidate;//информация о программе и даты (Programm Information and Date)
float discrT1,//реальное время дискретизации (мкс)
mVOnChan;//сигнал (напряжение) на канале
bool forwc;//индикатор успешности чтения блока данных из файла
unsigned long bytesRead,
totRead,//всего прочитано байт
lpFileSizeHigh;//большой размер файла
totRead = 0;
pidate = new char[40];//готовим массивы для записи данных из файла
//открываем и читаем файл с экспериментальными данными
ContinRecFile = CreateFile(OpenDlg->FileName.c_str(), GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
//считываем параметры файл
forwc = ReadFile(ContinRecFile, (void*)pidate, sizeof(char) * 37, &bytesRead, 0);
totRead += bytesRead;
fileParametr = pidate;
i = fileParametr.AnsiPos("ElphAcqu v5");//ищем отметку о версии файла (программы)
if (i <= 0)//нет такой строки в файле
{
Experiment->DevEvents->Text = "этот файл не открою";//сообщение о невозможности прочитать файл неизвестного типа (не тот заголовок)
CloseHandle(ContinRecFile);//закрываем файл
return;
}
//переменные, уникальные для данной записи (т.е. все необходимые параметры)
/* последовательность записи обязательных параметров
sampls2mV ----(1) - коэффициент перевода амплитуд из отсчётов АЦП в (милли)вольты
oChanNumb ----(2) - количество используемых каналов
minDiscrTime -(3) - минимальное (истинное) время дискретизации
oDiscrTime ---(4) - пользовательское время дискретизации
*/
forwc = ReadFile(ContinRecFile, (void*)&chanls, sizeof(__int32), &bytesRead, 0); //количество сканируемых каналов
totRead += bytesRead;
forwc = ReadFile(ContinRecFile, (void*)&nGain, sizeof(__int32), &bytesRead, 0);//коэффициент усиления
totRead += bytesRead;
forwc = ReadFile(ContinRecFile, (void*)&discrT1, sizeof(float), &bytesRead, 0);//реальное время дискретизации (микросекунды)
totRead += bytesRead;
forwc = ReadFile(ContinRecFile, (void*)&discrT, sizeof(float), &bytesRead, 0); //эффективное время дискретизации (микросекунды)
totRead += bytesRead;
forwc = ReadFile(ContinRecFile, (void*)&Experiment->maxADCAmp, sizeof(__int32), &bytesRead, 0);//максимальная амплитуда АЦП (в отсчётах)
totRead += bytesRead;
forwc = ReadFile(ContinRecFile, (void*)&Experiment->maxVoltage, sizeof(float), &bytesRead, 0);//диапазон допустимых входных напряжений (милливольты)
totRead += bytesRead;
forwc = ReadFile(ContinRecFile, (void*)&leadChan, sizeof(__int32), &bytesRead, 0);//ведущий канал (основной сигнал)
totRead += bytesRead;
Experiment->a.m_nGain = nGain;//коэффициент усиления
sampl2mV = Experiment->maxVoltage / (Experiment->maxADCAmp * nGain);//коэффициент перевода отсчётов АЦП в милливольты = maxVoltage/(maxADCAmp * ADCGain)
ftChan = chanls;//количество каналов с полными развёртками (full trace channels)
effDT = discrT * chanls;//эффективное время дискретизации = discrT * chanls
bytesRead = (37 * sizeof(char)) + (3 * sizeof(float)) + (4 * sizeof(__int32));// * 2) ;//размер заголовка файла
if (totRead != bytesRead)//ошибка чтения
{
Experiment->DevEvents->Text = "ошибка чтения";//сообщение об ошибке
CloseHandle(ContinRecFile);//закрываем файл
return;
}
convertedData = OpenDlg->FileName;//имя файла с конвертированными данными
convertedData.Delete(convertedData.Length() - 3, 4);//удаляем расширение
if (cTyp)//конвертировать в pra-файл
{
SaveDlg->FileName = convertedData + ".pra";//имя файла
flSize = GetFileSize(ContinRecFile, &lpFileSizeHigh);//размер файла
flSize -= ((37 * sizeof(char)) + sizeof(__int32) + (3 * sizeof(float)));//вычитаем размер заголовка файла
flSize = floor((flSize / sizeof(short)) / chanls);//количество отсчётов на один канал
data = new short[chanls * flSize];//предвыделение памяти для данных
forwc = ReadFile(ContinRecFile, (void*)data, sizeof(short) * chanls * flSize, &bytesRead, 0);
dataCh = new short*[chanls];//предвыделение памяти для данных
for (i = 0; i < chanls; i++)
dataCh[i] = new short[flSize];//предвыделение памяти для данных
csSpecPoint->Clear();//
j = 0;
for (i = 0; i < chanls; i++)
for (t = 0; t < flSize; t++)
{
dataCh[i][t] = data[j];
j++;
}
delete[] data; data = NULL;
PStart->continRec = dataCh;//копия ссылки на массив данными
Graphs->gRF[0] = 0;//первый рисуемый канал
Graphs->gRF[1] = chanls;//последний рисуемый канал
for (i = 0; i < maxChannels; i++)
{
Graphs->curntSigChannls[i]->XValues->Multiplier = double(effDT) / 1000;//выставим множители для "быстрых" графиков
PStart->exmplChannls[i]->XValues->Multiplier = double(effDT) / 1000;//выставим множители для "быстрых" графиков
}
//рисум сигнал на в окне ПредСтарта и ждём команды
if (PStart->winDraw(flSize) == mrOk)//нажата кнопка "Стар" (запустить расчёт)
{
//ищем сигналы
recLen = (__int32)floor((float(StrToInt(PStart->LenSpont->Text) * 1000) / effDT) + 0.5);//длина развёртки сигнала (отсчёты)
backLen = (__int32)floor((float(StrToInt(PStart->BackTime->Text) * 1000) / effDT) + 0.5);//время назад (отсчёты)
multiCh = true;//режим сбора данных (true = многоканальный)
ftChan = 1 + (chanls - 1) * (__int32)multiCh;//количество каналов с полными развёртками (full trace channels)
gPorog = short((float)StrToInt(PStart->Porog->Text) / sampl2mV);//пороговое напряжение (отсчёты)
polarity = PStart->postCompInvert;//полярность
ExpNotes->addUMark->Tag = 0;//нет заметок
devExpParams_int = new __int32[ehead[2].numOfElements];//создаём массив с параметрами устройства и эксперимента (__int32)
devExpParams_int[0] = multiCh;//0//режим сбора данных (true = многоканальный)
devExpParams_int[1] = recLen;//1//длина развёртки сигнала в отсчётах
devExpParams_int[2] = (__int32)discrT;//2//время дискретизации (микросекунды)
devExpParams_int[3] = chanls;//3//количество сканируемых каналов
devExpParams_int[4] = leadChan;//4//ведущий канал (основной сигнал)
devExpParams_int[5] = nGain;//5//коэффициент усиления
devExpParams_int[6] = ExpNotes->addUMark->Tag;//6//количество заметок
devExpParams_int[7] = 1;//7//тип эксперимента, глобальный вариант
devExpParams_int[8] = 0;//8//gPreTime (в микросекундах)
devExpParams_int[9] = 0;//9//gPostTime (в микросекундах)
devExpParams_int[10] = (__int32)gPorog;//10//амплитудный порог (отсчёты)
devExpParams_int[11] = Experiment->maxADCAmp;//11//максимальная амплитуда (в отсчётах)
devExpParams_int[12] = -Experiment->maxADCAmp;//12//минимальная амплитуда (в отсчётах)
devExpParams_int[13] = Experiment->a.m_nFirstChannel;//13//ведущий аппаратный канал
devExpParams_int[14] = 0;//14//не используется
//float - параметры
devExpParams_float = new float[ehead[3].numOfElements];//создаём массив с параметрами устройства и эксперимента (float)
devExpParams_float[0] = sampl2mV;//0//коэффициент перевода амплитуд из отсчётов АЦП в милливольты = maxVoltage/(maxADCAmp * ADCGain)
devExpParams_float[1] = Experiment->maxVoltage;//1//диапазон входных напряжений (в милливольтах)
devExpParams_float[2] = -1;//2//период стимуляции
devExpParams_float[3] = discrT;//3//время дискретизации (микросекунды)
devExpParams_float[4] = 0;//4//не используется
devExpParams_float[5] = 0;//5//не используется
totSigNum = floor(flSize / recLen);//предельное количество спонтанных сигналов
if (totSigNum > limitSigNum)//ограничение на количество сигналов
totSigNum = limitSigNum;//указываем максимальное количество сигналов
gSignals = Graphs->CreatStructSignal(totSigNum, recLen);//структура с сигналами и их атрибутами
realSigNum = 0;//количество обнаруженных сигналов
i = 0;
while ((i < flSize) && (realSigNum < totSigNum))//анализируем ведущий канал
{
if ((dataCh[0][i] * polarity) > gPorog)//обнаружен сигнал (добавляем его)
{
gSignals[realSigNum].appear = i * effDT * 1e-6;//время возникновения сигнала-синхроимпульса (секунды от начала эксперимента)
for (t = 0; t < chanls; t++)//перебираем каналы
{
if ((i - backLen) < 0)//начальная часть сигнала не записана
k = backLen - i;//пропускаем недостающие отсчёты
else//весь сигнал записан
k = 0;//записываем все отсчёты
for (j = k; (j < recLen) && ((i + j) < flSize); j++)//перебираем отсчёты
{
gSignals[realSigNum].s[j] = dataCh[t][i - backLen + j] * polarity;//отсчёты сигнала
}
}
realSigNum++;//количество обнаруженных сигналов
i += (recLen - backLen);//пропускаем участок с обнаруженным сигналом
}
else
i++;//следующий отсчёт
}
gInd = new __int32[realSigNum];//индексы принятых сигналов. При удалении сигнала, убираем его номер из этого массива
for (i = 0; i < realSigNum; i++)
gInd[i] = i;//номера всех сигналов
Graphs->SaveExpDataToFile(1, NULL, realSigNum, false);//сохранение данных
}
//удаляем массивы
delete[] dataCh; dataCh = NULL;
}
else//конвертирова в текст
{
convertedData += ".dat";
stream = fopen(convertedData.c_str(), "w");//создаём файл с текстовыми данными
fprintf(stream, "time");//вписываем заголовок
for (i = 0; i < chanls; i++)
{
fileParametr = "\tChann_";
fileParametr += IntToStr(i + 1);
fprintf(stream, fileParametr.c_str());//вписываем заголовок
}
fprintf(stream, "\nsec");//вписываем заголовок
for (i = 0; i < chanls; i++)
fprintf(stream, "\tmV");//вписываем заголовок
fprintf(stream, "\n");//вписываем заголовок
//читаем, конвертируем и выводим данные в другой файл
dataBlock = new short[chanls];//блок с одиночыми отсчётами от каждого канала
t = 0;//счётчик времени
recStep = floor(discrT / discrT1);//шаг записи
while (forwc)
{
forwc = ReadFile(ContinRecFile, (void*)dataBlock, chanls * sizeof(short), &bytesRead, 0);
forwc = (bytesRead > 0);
if (forwc)//если что-то прочиталось
{
fprintf(stream, "%f", (t * discrT * chanls * 1e-6));//вписываем время (секунды)
//плюс (discrTime * номер канала), т.к. реальная и пользовательская дискретизации не совпадают
for (i = 0; i < chanls; i++)
{
mVOnChan = (float)dataBlock[i] * sampl2mV;//сигнал (напряжение) на канале
fprintf(stream, "\t%6.2f", mVOnChan);//выводим значение напряжения на канале в данный момент
}
fprintf(stream, "\n");
}
t += recStep;//увеличивем счётчик времени
}
delete[] pidate; pidate = NULL;
delete[] dataBlock; dataBlock = NULL;
fclose(stream);//закрываем файл (закрываем поток вывода данных в файл)
CloseHandle(ContinRecFile);//закрываем файл
}
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::ShowTheChannlClick(TObject *Sender)
{
//показать параметры выбранного канала
TMenuItem *copyOfItem;//копия указателя на элемент списка каналов, вызвавший функцию (выбранный пользователем)
__int32 i;
//выяснить номер выбранного канала (элемента списка каналов)
copyOfItem = (TMenuItem*)Sender;//преобразуем к нужному типу данных ссылку на объекты вызвавший данную функцию
copyOfItem->Checked = true;//меняем параметры вызвашего данную функцию объекта (например ChannNumb[0])
gRF[0] = ShowChanN->IndexOf(copyOfItem);//получаем номер выбранного канала
ShowChanN->Caption = "Канал " + IntToStr(gRF[0] + 1);//указан выбранный канал
gRF[1] = gRF[0] + 1;//отображается один выбранный канал
FillParamTable();//заполняем таблицу значениями параметров
ResetVisibility();//запускаем прорисовку
}
//---------------------------------------------------------------------------
void __fastcall TGraphs::SAllChanClick(TObject *Sender)
{
//меняем отображение каналов
if (!SAllChan->Checked)//рисовать все каналы
{
SAllChan->Checked = true;
ShowChanN->Caption = "Все каналы";
gRF[0] = 0;//первый отображаемый сигнал
gRF[1] = ftChan;//последний отображаемый сигнал
FillParamTable();//заполняем таблицу значениями параметров
ResetVisibility();//запускаем прорисовку
}
}
//---------------------------------------------------------------------------
|
// Copyright 2012 Yandex
#ifndef LTR_UTILITY_CONTAINER_UTILITY_H_
#define LTR_UTILITY_CONTAINER_UTILITY_H_
#include <stdexcept>
#include <sstream>
#include "boost/unordered_map.hpp"
#include "boost/unordered_set.hpp"
using std::logic_error;
using std::stringstream;
namespace ltr {
namespace utility {
template <class TCont>
static inline bool Contains(const TCont& cont,
const typename TCont::key_type& key) {
return cont.find(key) != cont.end();
}
template <class ValueType>
static inline ValueType &SafeInsert(
boost::unordered_map<string, ValueType> &container,
const char* key) {
if (!key) {
throw logic_error("empty name!!!!");
}
if (Contains(container, key)) {
throw logic_error("Container already contains " + string(key) + "!!!");
}
return container[key];
}
static inline void SafeInsert(
boost::unordered_set<string>& cont,
const char* key) {
if (!key) {
return;
}
if (Contains(cont, key)) {
throw logic_error("Container already contains " + string(key) + "!!!");
}
cont.insert(key);
}
/**
* Converts boost::unordered_map<Key, Value> to string
* if the ToString(Value) is defined and operator << (ostream, Key)
* is defined.
* @param cont - cantainer to convert to string
* @returns converted string
*/
template <class Key, class Value>
inline string ToString(const boost::unordered_map<Key, Value>& cont) {
typedef typename boost::unordered_map<Key, Value>::const_iterator TIter;
stringstream out(stringstream::out);
size_t i = 0;
for (TIter it = cont.begin(); it != cont.end(); ++it)
out << ++i << ")" << it->first << " " << ToString(it->second) << '\n';
return out.str();
}
/**
* Converts boost::unordered_set<Value> to string
* if the operator << (ostream, Value) is defined.
* @param cont - cantainer to convert to string
* @returns converted string
*/
template <class Value>
inline string ToString(const boost::unordered_set<Value>& cont) {
typedef typename boost::unordered_set<Value>::const_iterator TIter;
stringstream out(stringstream::out);
out << "set(";
for (TIter it = cont.begin(); it != cont.end(); ++it)
out << *it << "; ";
out << ")";
return out.str();
}
}
}
#endif //LTR_UTILITY_CONTAINER_UTILITY_H_
|
/*
There are ‘n’ number of balls in a container. Mr. Sharma and Singh want to take balls out from the container.
At each step, Mr. Sharma took ‘k’ balls out of the box and Mr. Singh took one-tenth of the remaining balls.
Suppose there are 29 balls at the moment and k=4. Then, Mr. Sharma will take 4 balls and Mr. Singh will take 2 balls (29-4 = 25; 25/10 = 2).
If there are less than ‘k’ balls remaining at some moment, then Mr. Sharma will take all the balls which will get the container empty.
The process will last until the container becomes empty.
Your task is to choose minimal ‘k’ for Mr. Sharma such that Mr. Sharma will take at least half of the balls from the container.
Input Format:
The Only line of input contains a single integer ‘n’.
Output Format:
Print a single integer denoting the minimal value of ‘k’.
Constraints:
1 <= n <= 10^18
Time Limit: 1 second
Sample Input:
68
Sample Output:
3
Explanation:
68-3 = 65; 65/10 = 6; 65-6 = 59
59-3 = 56; 56/10 = 5; 56-5 = 51
51-3 = 48; 48/10 = 4; 48-4 = 44
44-3 = 41; 41/10 = 4; 41-4 = 37
…..
…..
…..
6-3 = 3; 3/10 = 0; 3-0 = 3
3-3 = 0; 0/10 = 0; 0-0 = 0
*/
#include <bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ll long long int
ll n;
bool good(ll mid){
ll sharma=0;
ll x=n;
while(x>0){
ll add=min(x,mid);
sharma+=add;
x-=add;
x-=(x/10);
}
return 2*sharma >= n;
}
int main(){
IOS;
cin>>n;
ll l=1,r=n;
ll ans=0;
while(l<=r){
ll mid=(l+r)/2;
if(good(mid)){
ans=mid;
r=mid-1;
}else l=mid+1;
}
cout<<ans<<'\n';
return 0;
}
|
/*
Name - Aman Jain
Date - 23-06-2020
*/
#include<bits/stdc++.h>
using namespace std;
int main (){
int verti,edges;
cin>>verti>>edges;
int visi[verti +1]={0};
vector<pair<int,int>> gr[verti+1]; //1 based vertices
for(int i=0; i<edges ;i++){
int x,y,w; //x,y edge from x to y having weight w
cin>>x>>y>>w;
gr[x].push_back({y,w});
gr[y].push_back({x,w});
}
// Min Heap
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> Q;
Q.push({0,1});
// weight,node
long long int mst=0;
while(!Q.empty()){
pair<int,int> best= Q.top();
Q.pop();
int weight=best.first;
int to= best.second;
// Not an active edge
if(visi[to]) continue;
mst+=weight;
visi[to]=1;
// to vertex is visited
for(auto x : gr[to]){
if(visi[x.first]==0){
// x.first is not visited
Q.push({x.second,x.first});
}
}
}
cout<<mst<<endl;
}
|
#pragma once
#include <QDialog>
#include <memory>
struct ui_about_us_dlg;
class about_us_dlg final : public QDialog
{
public:
static void show_info (const QString & text, const QString & qr_code);
static std::unique_ptr<about_us_dlg> make (QWidget * parent = nullptr);
~about_us_dlg () override;
void set_qr_code_text (const QString & text);
void set_description (const QString & text);
private:
about_us_dlg(QWidget * parent);
bool init ();
bool init_ui ();
private:
std::unique_ptr<ui_about_us_dlg> ui;
};
|
// Programmable-Air
// Author: tinkrmind
// https://github.com/orgs/Programmable-Air
//
// Basic example of using Suck function of the Programmable-Air board.
// The neopixels show pressure. Cyan for low pressure and Purple for high pressure
// Brighter color means more extreme pressure. Bright cyan means lower pressure than dim cyan and brighter purple means higher pressure tham dim purple. At atmospheric presure,lights will be off.
//
// PCB v0.3/v0.4/v0.5
#include "programmable_air.h"
#define DEBUG 1
void setup() {
initializePins();
}
void loop() {
delayWhileReadingPressure(200);
// if the BLUE button is pressed suck air out of the output, else, vent to atmosphere
if(readBtn(BLUE)){
// switch on Pump 1 (suck) to 50% duty cycle
switchOnPump(1, 50);
suck();
} else{
vent();
}
}
|
/**************************************************************************************
* File Name : ColorInChar.hpp
* Project Name : Keyboard Warriors
* Primary Author : JeongHak Kim
* Secondary Author :
* Copyright Information :
* "All content 2019 DigiPen (USA) Corporation, all rights reserved."
**************************************************************************************/
#pragma once
class [[nodiscard]] ColorBit
{
public:
ColorBit()
: r(0), g(0), b(0), a(0) {}
ColorBit(unsigned char same_intensity, unsigned char alpha = 255)
: r(same_intensity), g(same_intensity), b(same_intensity), a(alpha) {}
ColorBit(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255)
: r(r), g(g), b(b), a(a) {}
unsigned char r, g, b, a;
};
|
#include <iostream>
using namespace std;
struct Cyclist{
int id,n_id;
};
struct Node{
Node *parent;
int Rank;
int id,n_id;
};
Node *makeSet(Cyclist x)
{
Node *q=new Node;
q->id=x.id;
q->n_id=x.n_id;
q->parent=q;
}
Node *findSet(Node *x)
{
if(x->parent!=x)
x->parent=findSet(x->parent);
return x->parent;
}
void Union(Node *x,Node *y)
{
x=findSet(x);
y=findSet(y);
if(x->Rank<y->Rank)
{
x->parent=y;
}
else
{
y->parent=x;
if(y->Rank==x->Rank) x->Rank++;
}
}
int smallestGroup(Cyclist cyclist[],int n)
{
Node* tab[n];
for(int i=0;i<n;i++)
{
tab[i]=MakeSet(t[i]);
}
for(int i=0;i<n;i++)
{
if(findSet(tab[i])!=findSet(tab[tab[i].n_id)])
{
Union(findSet(tab[i]),findSet(tab[tab[i].n_id)]);
}
}
int suma=0;
for(int i=0;i<n;i++)
{
if(t[i]->Rank>suma) suma=t[i]->Rank;
}
return suma;
}
int main()
{
cout << "Hello world!" << endl;
return 0;
}
|
#ifndef MCP4651_H
#define MCP4651_H
#if (ARDUINO >=100)
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include <Wire.h>
class MCP4651 {
protected:
uint8_t address;
public:
// Constructor
MCP4651(uint8_t addr = 0x28);
// Methods
void begin();
void write(uint8_t pot, uint16_t val);
void increment(uint8_t pot);
void decrement(uint8_t pot);
};
#endif
|
/*
* Ref_Object.h
*
* Created on: Jun 8, 2017
* Author: root
*/
#ifndef REF_OBJECT_H_
#define REF_OBJECT_H_
#include "Common.h"
namespace CommBaseOut
{
class Ref_Object
{
public:
Ref_Object(void) : ref_count_(0)
{
}
Ref_Object(const Ref_Object& val)
{
ref_count_ = 0;
}
public:
virtual ~Ref_Object(void)
{
}
void addref(void)
{
GUARD(CSimLock, obj, &ref_lock_);
++ref_count_;
}
bool release(void)
{
GUARD(CSimLock, obj, &ref_lock_);
--ref_count_;
if(ref_count_ <= 0)
{
obj.UnLock();
delete this;
return true;
}
return false;
}
Ref_Object& operator = (const Ref_Object& val)
{
if(this == &val)
return *this;
GUARD(CSimLock, obj, &ref_lock_);
ref_count_ = 0;
obj.UnLock();
return *this;
}
protected:
volatile long ref_count_;
CSimLock ref_lock_;
};
}
#endif /* REF_OBJECT_H_ */
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
void findminpos(string str,vector<int> & pos)
{
int l,minpos;
char min;
l=str.length();
min=str[0];
minpos=0;
pos.clear();
for(int i=1;i<l;i++)
{
if(str[i]<min)
{
pos.clear();
min=str[i];
minpos=i;
}
else if(str[i]==min)
{
pos.push_back(minpos);
minpos=i;
}
}
pos.push_back(minpos);
}
int main()
{
std::ios::sync_with_stdio(false);
int N,minpos,l;
string bead,str;
vector<int> pos,temp;
char min;
vector<int>::iterator it;
cin>>N;
while(N>0)
{
cin>>bead;
l=bead.length();
findminpos(bead,pos);
str="";
for(int i=1;i<l;i++)
{
if(pos.size()==1)
{
break;
}
temp.clear();
it=pos.begin();
minpos=*it;
min=bead[((*it)+i)%l];
it++;
for(;it!=pos.end();it++)
{
if(bead[((*it)+i)%l]<min)
{
temp.clear();
min=bead[((*it)+i)%l];
minpos=*it;
}
else if(bead[((*it)+i)%l]==min)
{
temp.push_back(minpos);
minpos=*it;
}
}
temp.push_back(minpos);
pos=temp;
/*for(it=pos.begin();it!=pos.end();it++)
str=str+str[(*it+i)%l];
findminpos(str,temp);
for(it=temp.begin();it!=temp.end();it++)
{
*it=pos[*it];
}
pos=temp;*/
}
cout<<pos[0]+1<<endl;
/*
min=bead[0];
minpos=0;
for(int i=1;i<l;i++)
{
if(bead[i]<min)
{
pos.clear();
min=bead[i];
minpos=i;
}
else if(bead[i]==min)
{
pos.push_back(minpos);
minpos=i;
}
}
pos.push_back(minpos);
temp.clear();
it=pos.begin();
minpos=*it;
min=bead[(*it)+1];
minj=0;
it++;
for(;it!=pos.end();it++)
{
if(bead[(*it)+1]<min)
{
temp.clear();
min=bead[(*it)+j];
minpos=*it;
minj=j;
}
else if(bead[(*it)+j]==min)
{
temp.push_back(minj);
minpos=*it;
j=minj;
}
}
temp.push_back(minpos);
pos.clear();
for(it=temp.begin();it!=temp.end();it++)
{
pos.pushback(*it);
}*/
/*minpos=0;
for(int i=1;i<l;i++)
{
for(int j=0;j<l;j++)
{
if(bead[(i+j)%l]>bead[(minpos+j)%l])
break;
else if(bead[(i+j)%l]<bead[(minpos+j)%l])
minpos=i;
}
}
cout<<minpos+1<<endl;*/
N--;
}
return 0;
}
|
#include "scene_controller.h"
#include "assertion.h"
void SceneController::Load() {
DOUT() << "Loading Scenes" << std::endl;
level.Load("sandboxLevel");
editor.Load();
sandbox.Load();
stateMap = {
{ Scenes::Level, &level },
{ Scenes::Sandbox, &sandbox },
{ Scenes::Editor, &editor },
};
states.AddState(Scenes::Level);
states.AddState(Scenes::Sandbox);
states.AddState(Scenes::Editor);
states.ChangeState(Scenes::Level);
DOUT() << "Successfully loaded Scenes" << std::endl;
}
void SceneController::Reset() {
editor.Reset();
sandbox.Reset();
stateMap.clear();
states = StateMachine();
}
Scene& SceneController::CurrentScene() {
return *stateMap[states.State<Scenes>()];
}
void SceneController::LoadLevel(const std::string& name) {
editor.Reset();
editor.Load(name);
level.Reset();
level.Load(name);
}
const StateMachine& SceneController::SceneState() const {
return states;
}
StateMachine& SceneController::SceneState() {
return states;
}
LevelScene& SceneController::Level() {
return level;
}
EditorScene& SceneController::Editor() {
return editor;
}
SandboxScene& SceneController::Sandbox() {
return sandbox;
}
|
#include <iostream>
using namespace std;
int main()
{
int i,j,k;
int n;
cout<<"Enter the size of the array: ";
cin>>n;
int arr[n];
cout<<"Enter the elements of the array: ";
for(i=0;i<n;i++)
{
cin>>arr[i];
}
int sum;
cout<<"Enter the Sum: ";
cin>>sum;
int ans=0;
for(i=0;i<n - 2;i++)
{
for (int j = i+1; j < n-1; j++)
{
for (int k = j+1; k < n; k++)
{
if (arr[i] + arr[j] + arr[k] < sum)
{
ans++;
}
}
}
}
cout<<"The number of such pairs is :"<<ans;
return 0;
}
|
#pragma once
#include <iberbar/Renderer/Headers.h>
namespace iberbar
{
namespace Renderer
{
enum class EVertexElementSlot
{
Position = 0,
Color = 1,
Normal = 2,
Tex0 = 3,
Tex1 = Tex0 + 1,
Tex2 = Tex0 + 2,
Tex3 = Tex0 + 3,
Tex4 = Tex0 + 4,
Tex5 = Tex0 + 5,
Tex6 = Tex0 + 6,
Tex7 = Tex0 + 7,
};
enum EVertexElementUsage
{
Position = 0x0001 << (int)EVertexElementSlot::Position,
Color = 0x0001 << (int)EVertexElementSlot::Color,
Normal = 0x0001 << (int)EVertexElementSlot::Normal,
Tex0 = 0x0001 << (int)EVertexElementSlot::Tex0,
Tex1 = 0x0001 << (int)EVertexElementSlot::Tex1,
Tex2 = 0x0001 << (int)EVertexElementSlot::Tex2,
Tex3 = 0x0001 << (int)EVertexElementSlot::Tex3,
Tex4 = 0x0001 << (int)EVertexElementSlot::Tex4,
Tex5 = 0x0001 << (int)EVertexElementSlot::Tex5,
Tex6 = 0x0001 << (int)EVertexElementSlot::Tex6,
Tex7 = 0x0001 << (int)EVertexElementSlot::Tex7,
};
static const uint32 g_nRhiUniformBindPoint_Matrices = 13;
static const uint32 g_nRhiUniformBindPoint_UserMax = 9;
}
}
|
#include <iostream>
#include <sstream>
template<typename Key, typename V, typename Compare = std::less<Key>>
class map {
public:
explicit map(Compare const& cmp = {})
: cmp{cmp}
{}
Compare cmp{};
};
struct no_case_cmp {};
template<typename Target = std::string, typename Source = std::string>
Target to(Source arg) {
std::stringstream interp;
Target result;
if (!(interp << arg)
or !(interp >> result)
or !(interp >> std::ws).eof())
throw std::runtime_error{"to<>() failed"};
return result;
}
int main() {
map<std::string, int> m1;
map<std::string, int, std::less<std::string>> m2;
map<std::string, int, no_case_cmp> m3;
auto x1 = to<std::string, double>(1.2);
auto x2 = to<std::string>(1.2);
auto x3 = to<>(1.2);
auto x4 = to(1.2);
return 0;
}
|
// Created by: Peter KURNEV
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BOPDS_Curve_HeaderFile
#define _BOPDS_Curve_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Bnd_Box.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
#include <IntTools_Curve.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TColStd_ListOfInteger.hxx>
class IntTools_Curve;
class Bnd_Box;
class BOPDS_PaveBlock;
//! The class BOPDS_Curve is to store
//! the information about intersection curve
class BOPDS_Curve
{
public:
DEFINE_STANDARD_ALLOC
//! Empty constructor
BOPDS_Curve();
virtual ~BOPDS_Curve();
//! Constructor
//! @param theAllocator the allocator to manage the memory
BOPDS_Curve(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Modifier
//! Sets the curve <theC>
void SetCurve (const IntTools_Curve& theC);
//! Selector
//! Returns the curve
const IntTools_Curve& Curve() const;
//! Modifier
//! Sets the bounding box <theBox> of the curve
void SetBox (const Bnd_Box& theBox);
//! Selector
//! Returns the bounding box of the curve
const Bnd_Box& Box() const;
//! Selector/Modifier
//! Returns the bounding box of the curve
Bnd_Box& ChangeBox();
void SetPaveBlocks (const BOPDS_ListOfPaveBlock& theLPB);
//! Selector
//! Returns the list of pave blocks
//! of the curve
const BOPDS_ListOfPaveBlock& PaveBlocks() const;
//! Selector/Modifier
//! Returns the list of pave blocks
//! of the curve
BOPDS_ListOfPaveBlock& ChangePaveBlocks();
//! Creates initial pave block
//! of the curve
void InitPaveBlock1();
//! Selector/Modifier
//! Returns initial pave block
//! of the curve
Handle(BOPDS_PaveBlock)& ChangePaveBlock1();
//! Selector
//! Returns list of indices of technologic vertices
//! of the curve
const TColStd_ListOfInteger& TechnoVertices() const;
//! Selector/Modifier
//! Returns list of indices of technologic vertices
//! of the curve
TColStd_ListOfInteger& ChangeTechnoVertices();
//! Query
//! Returns true if at least one pave block of the curve
//! has edge
Standard_Boolean HasEdge() const;
//! Sets the tolerance for the curve.
void SetTolerance(const Standard_Real theTol)
{
myTolerance = theTol;
}
//! Returns the tolerance of the curve
Standard_Real Tolerance() const
{
return myTolerance;
}
//! Returns the tangential tolerance of the curve
Standard_Real TangentialTolerance() const
{
return myCurve.TangentialTolerance();
}
protected:
Handle(NCollection_BaseAllocator) myAllocator;
IntTools_Curve myCurve;
BOPDS_ListOfPaveBlock myPaveBlocks;
TColStd_ListOfInteger myTechnoVertices;
Bnd_Box myBox;
Standard_Real myTolerance;
private:
};
#include <BOPDS_Curve.lxx>
#endif // _BOPDS_Curve_HeaderFile
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2011 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser.
* It may not be distributed under any circumstances.
*/
#ifndef _SYNC_MYOPERA_PARSER_H_INCLUDED_
#define _SYNC_MYOPERA_PARSER_H_INCLUDED_
class XMLParser;
class TransferItem;
class OpSyncFactory;
#include "modules/xmlutils/xmltokenhandler.h"
#include "modules/xmlutils/xmlparser.h"
#include "modules/sync/sync_coordinator.h"
struct MyOperaItemTable
{
MyOperaItemTable(OpSyncItem::Key id, OpSyncDataItem::DataItemType item_type, const uni_char* item_name, const uni_char* item_obfuscated_name, BOOL item_primary_key, BOOL preserve_whitespace) : key(id), type(item_type), name(item_name), obfuscated_name(item_obfuscated_name), primary_key(item_primary_key), keep_whitespace(preserve_whitespace) {}
MyOperaItemTable() {}
OpSyncItem::Key key;
OpSyncDataItem::DataItemType type;
const uni_char* name;
const uni_char* obfuscated_name;
BOOL primary_key;
BOOL keep_whitespace;
};
class MyOperaSyncParser
: public OpSyncParser
{
friend class OpSyncFactory;
protected:
MyOperaSyncParser(OpSyncFactory* factory, OpInternalSyncListener* listener);
public:
virtual ~MyOperaSyncParser();
OP_STATUS Connect(MessageHandler* mh, OpString& url, UINT32 port, OpString& username, OpString& password);
/**
* @name Implementation of OpSyncParser
* @{
*/
virtual OpSyncError Parse(const uni_char* data, size_t length, const URL& url);
virtual OpSyncError PrepareNew(const URL& url);
virtual OpSyncDataCollection* GetIncomingSyncItems() { return &m_incoming_sync_items; }
virtual void ClearIncomingSyncItems(BOOL remove_deleted);
virtual OpString* GetErrorMessage() { return &m_error_message; }
virtual void ClearError() { m_error_message.Empty(); }
virtual OpSyncItem::Key GetPrimaryKey(OpSyncDataItem::DataItemType datatype);
virtual const uni_char* GetPrimaryKeyName(OpSyncDataItem::DataItemType datatype);
virtual OpSyncItem::Key GetPreviousRecordKey(OpSyncDataItem::DataItemType datatype);
virtual const uni_char* GetPreviousRecordKeyName(OpSyncDataItem::DataItemType datatype);
virtual OpSyncItem::Key GetParentRecordKey(OpSyncDataItem::DataItemType datatype);
virtual const uni_char* GetParentRecordKeyName(OpSyncDataItem::DataItemType datatype);
virtual const uni_char* GetObfuscatedName(const uni_char* tagname);
virtual const uni_char* GetRegularName(const uni_char* obfuscated_name);
virtual BOOL MaintainWhitespace(const uni_char* tag_name);
/** @} */ // Implementation of OpSyncParser
/**
* @param xmlout receives on output the generated xml document in utf8
* encoding.
*/
OP_STATUS GenerateXML(OpString8& xmlout, OpSyncDataCollection& items_to_sync);
private:
OP_STATUS CharacterDataHandler(const uni_char* s, int len);
OpSyncDataCollection m_incoming_sync_items;
OpString m_error_message;
XMLParser* m_xml_parser;
XMLParser::Listener* m_xml_parser_listener;
class MyOperaSyncXMLTokenHandler* m_xml_token_handler;
#ifdef DEBUG_LIVE_SYNC
OpString m_log_folder;
#endif // DEBUG_LIVE_SYNC
SyncSupportsState m_merge_actions;
};
inline int ascii_strcmp(const uni_char* src, const uni_char* dst)
{
int ret = 0;
// assumes uni_char is unsigned on the platform!
while(!(ret = *src - *dst) && *dst)
++src, ++dst;
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return( ret );
}
#endif //_SYNC_MYOPERA_PARSER_H_INCLUDED_
|
//
// linked_list.h
// DataStructures
//
// Created by Tri Khuu on 1/30/18.
// Copyright © 2018 TK. All rights reserved.
//
#ifndef linked_list_h
#define linked_list_h
#include <iostream>
using namespace std;
namespace LinkedList {
template<class T>
struct SingleLinkedListNode
{
/** Value. */
T value;
/** Pointers to next node. */
SingleLinkedListNode<T>* next_node;
SingleLinkedListNode<T>(T _data);
~SingleLinkedListNode<T>();
};
template <class T>
class SingleLinkedList
{
private:
SingleLinkedListNode<T>* head;
SingleLinkedListNode<T>* tail;
unsigned long list_size;
public:
SingleLinkedList();
~SingleLinkedList<T>();
void PushToHead(T _data);
void PushToTail(T _data);
void DeleteNode(T _data);
void DeleteAllNodes(T _data);
bool Contains(T _data);
void Reverse();
T PopHead();
T PopTail();
T PeekHead();
T PeekTail();
unsigned long Size();
void PrintSingleLinkedList();
};
};
#endif /* linked_list_h */
|
#ifndef _ROS_SERVICE_UpdateThrusterLayout_h
#define _ROS_SERVICE_UpdateThrusterLayout_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace sub8_msgs
{
static const char UPDATETHRUSTERLAYOUT[] = "sub8_msgs/UpdateThrusterLayout";
class UpdateThrusterLayoutRequest : public ros::Msg
{
public:
uint32_t dropped_thrusters_length;
char* st_dropped_thrusters;
char* * dropped_thrusters;
UpdateThrusterLayoutRequest():
dropped_thrusters_length(0), dropped_thrusters(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->dropped_thrusters_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->dropped_thrusters_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->dropped_thrusters_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->dropped_thrusters_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->dropped_thrusters_length);
for( uint32_t i = 0; i < dropped_thrusters_length; i++){
uint32_t length_dropped_thrustersi = strlen(this->dropped_thrusters[i]);
memcpy(outbuffer + offset, &length_dropped_thrustersi, sizeof(uint32_t));
offset += 4;
memcpy(outbuffer + offset, this->dropped_thrusters[i], length_dropped_thrustersi);
offset += length_dropped_thrustersi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t dropped_thrusters_lengthT = ((uint32_t) (*(inbuffer + offset)));
dropped_thrusters_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
dropped_thrusters_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
dropped_thrusters_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->dropped_thrusters_length);
if(dropped_thrusters_lengthT > dropped_thrusters_length)
this->dropped_thrusters = (char**)realloc(this->dropped_thrusters, dropped_thrusters_lengthT * sizeof(char*));
dropped_thrusters_length = dropped_thrusters_lengthT;
for( uint32_t i = 0; i < dropped_thrusters_length; i++){
uint32_t length_st_dropped_thrusters;
memcpy(&length_st_dropped_thrusters, (inbuffer + offset), sizeof(uint32_t));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_dropped_thrusters; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_dropped_thrusters-1]=0;
this->st_dropped_thrusters = (char *)(inbuffer + offset-1);
offset += length_st_dropped_thrusters;
memcpy( &(this->dropped_thrusters[i]), &(this->st_dropped_thrusters), sizeof(char*));
}
return offset;
}
const char * getType(){ return UPDATETHRUSTERLAYOUT; };
const char * getMD5(){ return "b67ed41009ef6b2c76bf4e56fcd5bd49"; };
};
class UpdateThrusterLayoutResponse : public ros::Msg
{
public:
UpdateThrusterLayoutResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return UPDATETHRUSTERLAYOUT; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class UpdateThrusterLayout {
public:
typedef UpdateThrusterLayoutRequest Request;
typedef UpdateThrusterLayoutResponse Response;
};
}
#endif
|
/*
* Copyright (c) 2007, Cameron Rich
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the axTLS project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef BIGINT_HEADER
#define BIGINT_HEADER
#include "crypto.h"
namespace youmecommon
{
BI_CTX *bi_initialize(void);
void bi_terminate(BI_CTX *ctx);
void bi_permanent(bigint *bi);
void bi_depermanent(bigint *bi);
void bi_clear_cache(BI_CTX *ctx);
void bi_free(BI_CTX *ctx, bigint *bi);
bigint *bi_copy(bigint *bi);
bigint *bi_clone(BI_CTX *ctx, const bigint *bi);
void bi_export(BI_CTX *ctx, bigint *bi, uint8_t *data, int size);
bigint *bi_import(BI_CTX *ctx, const uint8_t *data, int len);
bigint *int_to_bi(BI_CTX *ctx, comp i);
/* the functions that actually do something interesting */
bigint *bi_add(BI_CTX *ctx, bigint *bia, bigint *bib);
bigint *bi_subtract(BI_CTX *ctx, bigint *bia,
bigint *bib, int *is_negative);
bigint *bi_divide(BI_CTX *ctx, bigint *bia, bigint *bim, int is_mod);
bigint *bi_multiply(BI_CTX *ctx, bigint *bia, bigint *bib);
bigint *bi_mod_power(BI_CTX *ctx, bigint *bi, bigint *biexp);
bigint *bi_mod_power2(BI_CTX *ctx, bigint *bi, bigint *bim, bigint *biexp);
int bi_compare(bigint *bia, bigint *bib);
void bi_set_mod(BI_CTX *ctx, bigint *bim, int mod_offset);
void bi_free_mod(BI_CTX *ctx, int mod_offset);
#ifdef CONFIG_SSL_FULL_MODE
void bi_print(const char *label, bigint *bi);
bigint *bi_str_import(BI_CTX *ctx, const char *data);
#endif
/**
* @def bi_mod
* Find the residue of B. bi_set_mod() must be called before hand.
*/
#define bi_mod(A, B) bi_divide(A, B, ctx->bi_mod[ctx->mod_offset], 1)
/**
* bi_residue() is technically the same as bi_mod(), but it uses the
* appropriate reduction technique (which is bi_mod() when doing classical
* reduction).
*/
#if defined(CONFIG_BIGINT_MONTGOMERY)
#define bi_residue(A, B) bi_mont(A, B)
bigint *bi_mont(BI_CTX *ctx, bigint *bixy);
#elif defined(CONFIG_BIGINT_BARRETT)
#define bi_residue(A, B) bi_barrett(A, B)
bigint *bi_barrett(BI_CTX *ctx, bigint *bi);
#else /* if defined(CONFIG_BIGINT_CLASSICAL) */
#define bi_residue(A, B) bi_mod(A, B)
#endif
#ifdef CONFIG_BIGINT_SQUARE
bigint *bi_square(BI_CTX *ctx, bigint *bi);
#else
#define bi_square(A, B) bi_multiply(A, bi_copy(B), B)
#endif
#ifdef CONFIG_BIGINT_CRT
bigint *bi_crt(BI_CTX *ctx, bigint *bi,
bigint *dP, bigint *dQ,
bigint *p, bigint *q,
bigint *qInv);
#endif
}
#endif
|
#include "stdafx.h"
#include "KeyBoard.h"
int Keyboard::Key = 0;
char Keyboard::GetKeyChar()
{
char res = 0;
if (g_Key >= 65 && g_Key <= 90)
{
// a ~ z
if (g_isPressShift)
{
res = g_Key;
}
else
{
res = g_Key + 32;
}
}
else if (g_Key >= 48 && g_Key <= 57)
{
// 数字
res = g_Key;
}
else if (g_Key >= 96 && g_Key <= 105)
{
// テンキーの数字
res = g_Key - 48;
}
else
{
switch (g_Key)
{
case VK_OEM_102:
if (g_isPressShift)
res = '_';
else
res = '\\';
break;
}
}
Key = g_Key;
g_Key = 0;
return res;
}
bool Keyboard::isTrriger(KeyboardEve ke)
{
return Key == ke;
}
|
#include "Racional.hpp"
#include <string>
#include <iostream>
using namespace std;
Racional::Racional(){
}
Racional::Racional(int n, int d){
num = n;
den = d;
simplificar();
}
int Racional::getNum(){
return num;
}
int Racional::getDen(){
return den;
}
Racional Racional::suma(Racional r1, Racional r2){
//cout << "entro r" << endl;
int nNum, nDen;
nNum = (r1.getNum() * r2.getDen()) + (r1.getDen() * r2.getNum());
nDen = r1.getDen() * r2.getDen();
Racional resul(nNum, nDen);
return resul;
}
Racional Racional::mult(Racional r1, Racional r2){
//cout << "entro r" << endl;
int nNum, nDen;
nNum = r1.getNum() * r2.getNum();
nDen = r1.getDen() * r2.getDen();
Racional resul(nNum, nDen);
return resul;
}
void Racional::simplificar(){
for(int i = 1;i <= den;i++){
if(num % i == 0 && den % i == 0){
num /= i;
den /= i;
}
}
}
string Racional::toString(){
string salida;
(den == 1 ? salida = to_string(num) : salida = to_string(num) + "/" + to_string(den));
return salida;
}
|
#pragma once
#include <nonstd/optional.hpp>
#include <scip/scip.h>
#include "ecole/scip/type.hpp"
#include "ecole/scip/view.hpp"
namespace ecole {
namespace scip {
using nonstd::optional;
class VarProxy : public Proxy<SCIP_Var> {
public:
using Proxy::Proxy;
static VarProxy const None;
optional<real> ub_local() const noexcept;
optional<real> lb_local() const noexcept;
optional<real> best_sol_val() const noexcept;
optional<real> avg_sol() const noexcept;
var_type type_() const noexcept;
friend class Model;
};
using VarView = View<VarProxy>;
} // namespace scip
} // namespace ecole
|
#include <iostream>
#include <vector>
#include <cmath>
#include <ctime>
using namespace std;
int tc, m1, m2, n;
int Size = 1;
int aSize = 1;
int heapSize;
int AheapSize;
int m2res = 0;
vector<int> vec;
vector<int> accvec;
void constructHeap(int);
void heapSort();
int deleteMax(int);
int fixHeap(int, int, int);
int comp(int);
void AccconstructHeap(int);
void AcceleratedheapSort();
int AccdeleteMax(int);
void fixHeapFast(int, int, int, int);
int promote(int, int, int, int);
void bubbleUpHeap(int, int, int);
int Acomp(int);
int main(int argc, const char * argv[]) {
// freopen("input.txt", "r", stdin);
// freopen("output.txt","w+",stdout);
scanf("%d", &tc);
while (tc--) {
Size = 1;
aSize = 1;
vec.clear();
accvec.clear();
heapSize = 0;
AheapSize = 0;
m2res = 0;
scanf("%d", &n);
while (1) {
if (Size > n)
break;
Size *= 2;
}
aSize = Size;
vec.resize(Size);
accvec.resize(aSize);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
vec[i + 1] = a;
accvec[i + 1] = a;
}
scanf("%d%d", &m1, &m2);
heapSize = n + 1;
AheapSize = n + 1;
clock_t start_time, end_time;
start_time = clock();
heapSort();
end_time = clock();
double simpleHeapTime = (double)(end_time - start_time) / CLOCKS_PER_SEC;
start_time = clock();
AcceleratedheapSort();
end_time = clock();
double FastHeapTime = (double)(end_time - start_time) / CLOCKS_PER_SEC;
printf("%0.3f %0.3f\n", FastHeapTime, simpleHeapTime);
}
return 0;
}
void constructHeap(int node) {
if (node <= (Size) / 2) {
constructHeap(2 * node);
constructHeap(2 * node + 1);
int K = vec[node];
fixHeap(node, K, 0);
}
return;
}
int comp(int node) {
if (2 * node + 1 >= heapSize)
return 2 * node;
return (vec[node * 2] < vec[node * 2 + 1] ? node * 2 + 1 : node * 2);
}
int fixHeap(int node, int key, int depth) {
if (node > (heapSize) / 2 || 2 * node >= heapSize) {
vec[node] = key;
return depth - 1;
}
else {
int maxChildIdx = comp(node);
if (vec[maxChildIdx] <= key) {
vec[node] = key;
return depth - 1;
}
else {
int temp = vec[maxChildIdx];
vec[maxChildIdx] = key;
vec[node] = temp;
return fixHeap(maxChildIdx, key, depth + 1);
}
}
}
int deleteMax(int lastIdx) {
int ret = vec[1];
int last = vec[lastIdx];
swap(vec[1], vec[lastIdx]);
heapSize = heapSize - 1;
int res = fixHeap(1, last, 0);
if (m1 == n - lastIdx + 1) {
printf("%d ", res);
}
return ret;
}
void heapSort() {
constructHeap(1);
for (int i = n; i >= 1; i--) {
int curMax = deleteMax(i);
vec[i] = curMax;
if (n - i + 1 == m1) {
return;
}
}
}
void AcceleratedheapSort() {
AccconstructHeap(1);
for (int i = n; i >= 1; i--) {
int curMax = AccdeleteMax(i);
accvec[i] = curMax;
if (n - i + 1 == m2) {
return;
}
}
}
int AccdeleteMax(int lastIdx) {
int ret = accvec[1];
int last = accvec[lastIdx];
AheapSize = AheapSize - 1;
swap(accvec[1], accvec[lastIdx]);
m2res = 0;
fixHeapFast(last, 1, (int)log2(AheapSize), n - lastIdx + 1);
if (n - lastIdx + 1 == m2) {
printf("%d\n", m2res);
}
return ret;
}
void AccconstructHeap(int node) {
if (node < (aSize) / 2) {
AccconstructHeap(2 * node);
AccconstructHeap(2 * node + 1);
int K = accvec[node];
fixHeapFast(K, node, (int)log2(aSize) - (int)log2(node) - 1, INT_MAX);
}
return;
}
int Acomp(int node) {
if (2 * node >= AheapSize)
return -1;
if (2 * node + 1 >= AheapSize)
return 2 * node;
return (accvec[node * 2] < accvec[node * 2 + 1] ? node * 2 + 1 : node * 2);
}
int promote(int hStop, int vacant, int h, int key) {
int vacStop;
if (h <= hStop) {
vacStop = vacant;
}
else {
int idx = Acomp(vacant);
if (idx == -1)
return vacant;
accvec[vacant] = accvec[idx];
vacStop = promote(hStop, idx, h - 1, key);
}
return vacStop;
}
void bubbleUpHeap(int root, int key, int vacant) {
if (root == vacant)
accvec[vacant] = key;
else {
int parent = vacant / 2;
if (accvec[parent] <= key) {
swap(accvec[vacant], accvec[parent]);
bubbleUpHeap(root, key, parent);
}
else {
accvec[vacant] = key;
}
}
}
void fixHeapFast(int key, int vacant, int h, int cnt) {
if (h <= 0 || AheapSize == 2) {
return;
}
else if (h == 1) {
int maxChildNode = Acomp(vacant);
if (maxChildNode == -1) {
return;
}
swap(accvec[vacant], accvec[maxChildNode]);
if (accvec[vacant] <= key) {
if (cnt == m2) {
m2res = accvec[vacant];
}
swap(accvec[vacant], accvec[maxChildNode]);
}
}
else {
int hStop = (h) / 2;
int vacStop = promote(hStop, vacant, h, key);
accvec[vacStop] = key;
int vacParent = vacStop / 2;
if (accvec[vacParent] <= accvec[vacStop]) {
if (cnt == m2) {
m2res = accvec[vacParent];
}
accvec[vacStop] = accvec[vacParent];
bubbleUpHeap(vacant, key, vacParent);
}
else {
fixHeapFast(key, vacStop, hStop, cnt);
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.