int main() { float x, y; float radius, theta; float degree; printf("Please enter the x and y coordinates for your point: "); scanf("%f%f", &x, &y); radius = getRadius(x, y); theta = getTheta(x, y); degree = theta * (180 / acos(-1)); // convert radians to degrees /*adjust degree value for the correct quadrant*/ if(x < 0 && y > 0) degree = 180 + degree; else if(x < 0 && y < 0) degree = 180 + degree; else if(x > 0 && y < 0) degree = 360 + degree; else if(x < 0 && y == 0) degree = 180; else if(x == 0 && y < 0) degree = 270; printf("The Cartesian coordinates (%.2f, %.2f) correspond to the polar coordinates (%.2f, %.2f).\nThe polar radius is %.2f and the polar angle is %.2f degrees.\n", x, y, radius, degree, radius, degree); getQuadrant(x, y); return 0; }
float getLFraction(const int nEvtSim, const float planeL) { float nEvtPass = 0; std::cout << planeL << std::endl; const int fracSize = 10000; const float dimPlane = 10.0; const float rHemi = dimPlane/2.0*TMath::Sqrt(2.0); for(int genIter = 0; genIter < nEvtSim; genIter++){ float phiHemi = getPhi(fracSize); float thetaHemi = getTheta(fracSize); float planeX1 = getPlanePos(fracSize, dimPlane); float planeY1 = getPlanePos(fracSize, dimPlane); float hemiX = rHemi*cos(thetaHemi)*cos(phiHemi); float hemiY = rHemi*cos(thetaHemi)*sin(phiHemi); float delL = rHemi*sin(thetaHemi); float delX = hemiX - planeX1; float delY = hemiY - planeY1; float delR = TMath::Sqrt(delX*delX + delY*delY); float trajPhi = TMath::ATan2(delY, delX); float rExit = getRExit(trajPhi, dimPlane, planeX1, planeY1); if((delL/delR)*rExit >= planeL) nEvtPass++; } return nEvtPass/((float)nEvtSim); }
void AgentCore::dynamics() { double theta = getTheta(pose_.orientation); double x_dot_new = speed_command_sat_ * std::cos(theta); double y_dot_new = speed_command_sat_ * std::sin(theta); double theta_dot_new = speed_command_sat_ / vehicle_length_ * std::tan(steer_command_sat_); geometry_msgs::Pose pose_old = pose_; pose_.position.x = integrator(pose_.position.x, twist_.linear.x, x_dot_new, 1); pose_.position.y = integrator(pose_.position.y, twist_.linear.y, y_dot_new, 1); setTheta(pose_.orientation, integrator(theta, twist_.angular.z, theta_dot_new, 1)); twist_.linear.x = x_dot_new; twist_.linear.y = y_dot_new; twist_.angular.z = theta_dot_new; std::stringstream s; s << "Pose (" << pose_.position.x << ", " << pose_.position.y << ")."; console(__func__, s, DEBUG_VVV); s << "Twist (" << twist_.linear.x << ", " << twist_.linear.y << ")."; console(__func__, s, DEBUG_VVV); s << "System state (" << x_dot_new << ", " << y_dot_new << ", " << theta_dot_new << ")."; console(__func__, s, DEBUG_VVVV); broadcastPose(pose_, agent_frame_); broadcastPath(pose_, pose_old, agent_frame_); }
std::string GammaDeviate::make_repr(bool incl_seed) { std::ostringstream oss(" "); oss << "galsim.GammaDeviate("; if (incl_seed) oss << seedstring(split(serialize(), ' ')) << ", "; oss << "k="<<getK()<<", "; oss << "theta="<<getTheta()<<")"; return oss.str(); }
std::vector<double> BlackScholesGreeks::getAllGreeks() { std::vector<double> data; data.push_back(getPremium()); data.push_back(getDelta()); data.push_back(getGamma()); data.push_back(getVega()); data.push_back(getRho()); data.push_back(getTheta()); return data; }
EulerAngles::EulerAngles(const Dcm &dcm) : Vector(3) { setTheta(asinf(-dcm(2, 0))); if (fabsf(getTheta() - M_PI_2_F) < 1.0e-3f) { setPhi(0.0f); setPsi(atan2f(dcm(1, 2) - dcm(0, 1), dcm(0, 2) + dcm(1, 1)) + getPhi()); } else if (fabsf(getTheta() + M_PI_2_F) < 1.0e-3f) { setPhi(0.0f); setPsi(atan2f(dcm(1, 2) - dcm(0, 1), dcm(0, 2) + dcm(1, 1)) - getPhi()); } else { setPhi(atan2f(dcm(2, 1), dcm(2, 2))); setPsi(atan2f(dcm(1, 0), dcm(0, 0))); } }
//車体方向PID制御関数 S8 RA_directionCtrl_PID(float target) { static float bf_dev = 0.0; float dev = getTheta( ) - target; //float i_dev = i_dev + (dev * 0.0005); float d_dev = (dev - bf_dev) / 0.0005; bf_dev = dev; //S8 turn = Kp * dev + Ki * i_dev + Kd * d_dev; S8 turn = 1.0 * dev + 0.5 * d_dev; if (-100 > turn) { turn = -100; } else if (100 < turn) { turn = 100; } return turn; }
// modifies the main diagonal of the iteration matrix to introduce new dt void FCT_Solver::initialize(double _dt, Options* options, Performance* pp) { const real_t EPSILON = escript::DataTypes::real_t_eps(); const_TransportProblem_ptr fctp(transportproblem); const index_t* main_iptr = fctp->borrowMainDiagonalPointer(); const dim_t n = fctp->transport_matrix->getTotalNumRows(); const double theta = getTheta(); omega = 1. / (_dt * theta); dim_t i; Options options2; solve_free(fctp->iteration_matrix.get()); // fctp->iteration_matrix[i,i]=m[i]/(dt theta) -l[i,i] dt = _dt; #pragma omp parallel for private(i) for (i = 0; i < n; ++i) { const double m_i = fctp->lumped_mass_matrix[i]; const double l_ii = fctp->main_diagonal_low_order_transport_matrix[i]; if ( m_i > 0 ) { fctp->iteration_matrix->mainBlock->val[main_iptr[i]] = m_i * omega - l_ii; } else { fctp->iteration_matrix->mainBlock->val[main_iptr[i]] = std::abs(m_i * omega - l_ii)/(EPSILON*EPSILON); } } // allocate preconditioner/solver options2.verbose = options->verbose; if (method == PASO_LINEAR_CRANK_NICOLSON) { options2.preconditioner = PASO_GS; } else { options2.preconditioner = PASO_JACOBI; //options2.preconditioner = PASO_GS; } options2.use_local_preconditioner = false; options2.sweeps = -1; Performance_startMonitor(pp, PERFORMANCE_PRECONDITIONER_INIT); fctp->iteration_matrix->setPreconditioner(&options2); Performance_stopMonitor(pp, PERFORMANCE_PRECONDITIONER_INIT); }
void AgentCore::guidance() { double los_distance = std::sqrt(std::pow(pose_virtual_.position.x - pose_.position.x, 2) + std::pow(pose_virtual_.position.y - pose_.position.y, 2)); // std::atan2 automatically handle the los_distance == 0 case >> los_angle = 0 double los_angle = std::atan2(pose_virtual_.position.y - pose_.position.y, pose_virtual_.position.x - pose_.position.x); double speed_command = k_p_speed_*los_distance; speed_command_sat_ = saturation(speed_command, speed_min_, speed_max_); double steer_command = k_p_steer_*angles::shortest_angular_distance(getTheta(pose_.orientation), los_angle); steer_command_sat_ = saturation(steer_command, steer_min_, steer_max_); // there is no need to get sub-centimeter accuracy floor(speed_command_sat_, 1); std::stringstream s; s << "Guidance commands (" << speed_command_sat_ << ", " << steer_command_sat_ << ")."; console(__func__, s, DEBUG_VV); s << "LOS distance and angle (" << los_distance << ", " << los_angle << ")."; console(__func__, s, DEBUG_VVVV); }
void Unit::path(std::list<Unit*>::iterator itr) { CIwFVec2 force = CIwFVec2::g_Zero; std::list<Unit*>* units = game->getUnits(); float theta = getTheta(); CIwFVec2 dirToward = CIwFVec2::g_Zero; Unit* curUnit; //brute force - need to take advantage of theta sorting for (itr = units->begin() ; itr != units->end(); ++itr) { curUnit = *(itr); if ((*itr) != this && THETA_DIFF(curUnit->getTheta(), theta) < PATH_THETA_RANGE) { dirToward = position - curUnit->getPosition(); float dist = dirToward.GetLengthSquared(); force += dirToward.GetNormalised() * (curUnit->getSize()*REPEL_FACTOR / pow(dist, 1.875)); // We can tweak bottom factor later, this seems to work fine: ^ } } //attractive force for opponent leader Player* opponent = game->getLocalPlayer() != owner ? owner : game->getOpponentPlayer(); dirToward = ((Unit*)(opponent->getLeader()))->getPosition() - position; float dist = dirToward.GetLength(); if(dist > 0) force += dirToward.GetNormalised() * (LEADER_ATTRACTION / dist); //"spring" force to motivate circular pathing float centerR = (game->getWorldRadius().y + game->getWorldRadius().x)/2.0; float rDiff = centerR - r; force += position * ((rDiff < 0 ? -1 : 1) * WALL_REPEL * SQ(rDiff)); // Ternary is experimentally faster velocity = speed*force.GetNormalised(); setPosition(position + velocity); }
double Calculator::getIntensity(double Q) { std::complex<double> cppf1, cppf2; gsl_complex alpha, beta; gsl_complex gslf1, gslf2; int s; double avFactor; cppf1 = m_sf1->F(0.0, 0.0, Q, m_energy); cppf2 = m_sf2->F(0.0, 0.0, Q, m_energy); gslf1 = gsl_complex_rect(cppf1.real(), cppf1.imag()); gslf2 = gsl_complex_rect(cppf2.real(), cppf2.imag()); avFactor = exp(-2.0 / m_N); alpha = gsl_complex_rect (1.0, 0.0); beta = gsl_complex_rect (0.0, 0.0); /*set vector F (scattering factors)*/ gsl_vector_complex_set(F, 0, gslf1); gsl_vector_complex_set(F, 1, gslf2); /*set vector conj(F) (scattering factors)*/ gsl_vector_complex_set(Fconj, 0, gsl_complex_conjugate(gslf1)); gsl_vector_complex_set(Fconj, 1, gsl_complex_conjugate(gslf2)); /*set exp matrix*/ setMatrixExp(m_Exp, Q); /*find W = P * Exp * Ps * conj(F) vector:*/ /* (1) W = alpha * Ps * conj(F) + beta * W */ gsl_blas_zgemv (CblasNoTrans, alpha, m_Ps, Fconj, beta, W); /*printf("W(1):\n"); gsl_vector_complex_fprintf (stdout, W, "%g");*/ /* (2) W = alpha * Exp * tmp_vec + beta * W */ gsl_blas_zgemv (CblasNoTrans, alpha, m_Exp, W, beta, tmp_vec); /*printf("W(2):\n"); gsl_vector_complex_fprintf (stdout, tmp_vec, "%g");*/ /* (3) W = alpha * P * tmp_vec + beta * W */ gsl_blas_zgemv (CblasNoTrans, alpha, m_P, tmp_vec, beta, W); /*Find J0 = F.(Ps * conj(F)) */ gsl_blas_zgemv (CblasNoTrans, alpha, m_Ps, Fconj, beta, tmp_vec); gsl_blas_zdotu (F, tmp_vec, &J0); /*alpha = exp(-2 / N)*/ alpha = gsl_complex_rect (avFactor, 0.0); beta = gsl_complex_rect (0.0, 0.0); /*find T matrix: T = alpha * P * exp + beta * T*/ gsl_blas_zgemm (CblasNoTrans, CblasNoTrans, alpha, m_P, m_Exp, beta, T); /*printf("T:\n"); gsl_matrix_complex_fprintf (stdout, T, "%g");*/ /*Find Jns = F. (G * W) */ /*tmp_mat = I */ gsl_matrix_complex_set_identity (tmp_mat); /*tmp_mat = I - T */ gsl_matrix_complex_sub (tmp_mat, T); /*LU decomposition*/ gsl_linalg_complex_LU_decomp(tmp_mat, perm, &s); /*calculate product G * W = (I - T)^(-1) W directly using LU decomposition*/ gsl_linalg_complex_LU_solve (tmp_mat, perm, W, tmp_vec); /*calculate F.(G * W)*/ gsl_blas_zdotu (F, tmp_vec, &Jns); /*Find Js = F.(G^2 * (I - T^N) * W) however, this term should be negligible*/ /*result = N *(2 * Jns + J0) - Js */ alpha = gsl_complex_mul_real (Jns, 2.0 * avFactor); alpha = gsl_complex_add (alpha, J0); return m_N * m_I0 * GSL_REAL(alpha) * getPLGfactor(getTheta(Q)) + m_Ibg; }
double Circular::computeTopWidth(double y) { double theta = getTheta(y); return diameter * sin(theta / 2.0); }
double Circular::computeWettedPerimiter(double y) { double theta = getTheta(y); return 0.5 * theta * diameter; }
double Circular::computeArea(double y) { double theta = getTheta(y); return diameter * diameter / 8.0 * (theta - sin(theta)); }
/* ______________アウトコース走行区間検出_______________________ */ void setSection_out(){ /* アウトコース走行区間 */ static int wait_count = 0; wait_count++; float def_x = getXCoo() - buf_x; float def_y = getYCoo() - buf_y; float def_l = getDistance() - buf_l; float def_th = getTheta( ) - buf_th; switch(crt_sect){ case (START): //スタート→坂道 if(getInitGyroOffset() - 30 > (U32)ecrobot_get_gyro_sensor(NXT_PORT_S1) && wait_count > 500){ ecrobot_sound_tone(220, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = UP_SLOPE; trgt_speed = trgt_speed; } trgt_R = 0.0; break; case (UP_SLOPE): //坂道始点→頂点 if(def_l >= 30 && getInitGyroOffset() - 30 > (U32)ecrobot_get_gyro_sensor(NXT_PORT_S1)){ ecrobot_sound_tone(233, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = DOWN_SLOPE; trgt_speed = trgt_speed -10; } trgt_R = 0.0; break; case (DOWN_SLOPE): //頂点→坂道終点 //if(getDistance() >= 390){ if(def_l >= 90){ ecrobot_sound_tone(246, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = FST_CORNER; trgt_speed = trgt_speed - 10; } trgt_R = 0.0; break; case (FST_CORNER): //坂道終点→第一カーブ if(def_x >= 74 && def_y >= 70 && def_l >= 110 && def_th >= 90){ ecrobot_sound_tone(261, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = FST_STRAIGHT; trgt_speed = trgt_speed +20; } trgt_R = 67.59; break; case (FST_STRAIGHT): //第一カーブ終点→第一ストレート if(def_l >= 115){ ecrobot_sound_tone(277, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = SND_CORNER; trgt_speed = trgt_speed +10; } trgt_R = 0.0; break; case (SND_CORNER): //第一ストレート終点→第二カーブ if(def_x <= -95 && def_y <= -5 && def_l >= 245 && def_th >= 240){ ecrobot_sound_tone(293, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = SND_STRAIGHT; trgt_speed = trgt_speed; } trgt_R = 56.59; break; case (SND_STRAIGHT): //第二カーブ終点→第二ストレート if(def_x >= 40 && def_y <= -15 && def_l >= 40){ ecrobot_sound_tone(311, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = TRD_CORNER; trgt_speed = trgt_speed; } trgt_R = 0.0; break; case (TRD_CORNER): //第二ストレート終点→第三カーブ if(def_x <= -80 && def_y <= -80 && def_l >= 235 && def_th <= -210){ ecrobot_sound_tone(329, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = TRD_STRAIGHT; trgt_speed = trgt_speed; } trgt_R = -64.02; break; case (TRD_STRAIGHT): //第三カーブ終点→第三ストレート if(def_x <= -50 && def_y >= 105 && def_l >= 115){ ecrobot_sound_tone(349, 100, 50); changeSection(&buf_x, &buf_y, &buf_l, &buf_th); crt_sect = FIN_APPROACH; trgt_speed = trgt_speed; } trgt_R = 0.0; break; case (FIN_APPROACH): //第三ストレート終点→マーカー if(1){ ecrobot_sound_tone(369, 100, 50); trgt_speed = trgt_speed; } trgt_R = 51.80; break; case (STEPS): //階段 if(1){ ecrobot_sound_tone(369, 100, 50); } trgt_R = 51.80; break; case (TURN90D): if(1){ ecrobot_sound_tone(369, 100, 50); } trgt_R = 51.80; break; default: trgt_speed = 0; trgt_R = 0.0; break; } }
double QFFCSMaxEntEvaluationItem::getDLSQ() const { return 4.0*M_PI*getRefIndx()/(getLambda()/1e3)*sin(getTheta()/180.0*M_PI/2.0); }
double QFFCSMaxEntEvaluationItem::getDLSQ(QFRawDataRecord *r, int index, int model) const { return 4.0*M_PI*getRefIndx(r, index, model)/(getLambda(r, index, model)/1e3)*sin(getTheta(r, index, model)/180.0*M_PI/2.0); }
Bool_t DSelector_checkKFit::Process(Long64_t locEntry) { // The Process() function is called for each entry in the tree. The entry argument // specifies which entry in the currently loaded tree is to be processed. // // This function should contain the "body" of the analysis. It can contain // simple or elaborate selection criteria, run algorithms on the data // of the event and typically fill histograms. // // The processing can be stopped by calling Abort(). // Use fStatus to set the return value of TTree::Process(). // The return value is currently not used. //CALL THIS FIRST DSelector::Process(locEntry); //Gets the data from the tree for the entry //cout << "RUN " << Get_RunNumber() << ", EVENT " << Get_EventNumber() << endl; //TLorentzVector locProductionX4 = Get_X4_Production(); /******************************************** GET POLARIZATION ORIENTATION ******************************************/ //Only if the run number changes //RCDB environment must be setup in order for this to work! (Will return false otherwise) UInt_t locRunNumber = Get_RunNumber(); if(locRunNumber != dPreviousRunNumber) { dIsPolarizedFlag = dAnalysisUtilities.Get_IsPolarizedBeam(locRunNumber, dIsPARAFlag); dPreviousRunNumber = locRunNumber; } /********************************************* SETUP UNIQUENESS TRACKING ********************************************/ //ANALYSIS ACTIONS: Reset uniqueness tracking for each action //For any actions that you are executing manually, be sure to call Reset_NewEvent() on them here Reset_Actions_NewEvent(); //PREVENT-DOUBLE COUNTING WHEN HISTOGRAMMING //Sometimes, some content is the exact same between one combo and the next //e.g. maybe two combos have different beam particles, but the same data for the final-state //When histogramming, you don't want to double-count when this happens: artificially inflates your signal (or background) //So, for each quantity you histogram, keep track of what particles you used (for a given combo) //Then for each combo, just compare to what you used before, and make sure it's unique //EXAMPLE 1: Particle-specific info: set<Int_t> locUsedSoFar_BeamEnergy; //Int_t: Unique ID for beam particles. set: easy to use, fast to search //EXAMPLE 2: Combo-specific info: //In general: Could have multiple particles with the same PID: Use a set of Int_t's //In general: Multiple PIDs, so multiple sets: Contain within a map //Multiple combos: Contain maps within a set (easier, faster to search) set<map<Particle_t, set<Int_t> > > locUsedSoFar_Topology; bool usedTopology = false; //INSERT USER ANALYSIS UNIQUENESS TRACKING HERE /**************************************** EXAMPLE: FILL CUSTOM OUTPUT BRANCHES **************************************/ /* Int_t locMyInt = 7; dTreeInterface->Fill_Fundamental<Int_t>("my_int", locMyInt); TLorentzVector locMyP4(4.0, 3.0, 2.0, 1.0); dTreeInterface->Fill_TObject<TLorentzVector>("my_p4", locMyP4); for(int loc_i = 0; loc_i < locMyInt; ++loc_i) dTreeInterface->Fill_Fundamental<Int_t>("my_int_array", 3*loc_i, loc_i); //2nd argument = value, 3rd = array index */ /************************************************* LOOP OVER COMBOS *************************************************/ //Loop over combos for(UInt_t loc_i = 0; loc_i < Get_NumCombos(); ++loc_i) { //Set branch array indices for combo and all combo particles dComboWrapper->Set_ComboIndex(loc_i); // Is used to indicate when combos have been cut if(dComboWrapper->Get_IsComboCut()) // Is false when tree originally created continue; // Combo has been cut previously /********************************************** GET PARTICLE INDICES *********************************************/ //Used for tracking uniqueness when filling histograms, and for determining unused particles //Step 0 Int_t locBeamID = dComboBeamWrapper->Get_BeamID(); Int_t locPiPlusTrackID = dPiPlusWrapper->Get_TrackID(); Int_t locPiMinusTrackID = dPiMinusWrapper->Get_TrackID(); Int_t locProtonTrackID = dProtonWrapper->Get_TrackID(); /*********************************************** GET FOUR-MOMENTUM **********************************************/ // Get P4's: //is kinfit if kinfit performed, else is measured //dTargetP4 is target p4 //Step 0 TLorentzVector locBeamP4 = dComboBeamWrapper->Get_P4(); TLorentzVector locPiPlusP4 = dPiPlusWrapper->Get_P4(); TLorentzVector locPiMinusP4 = dPiMinusWrapper->Get_P4(); TLorentzVector locProtonP4 = dProtonWrapper->Get_P4(); // Get Measured P4's: //Step 0 TLorentzVector locBeamP4_Measured = dComboBeamWrapper->Get_P4_Measured(); TLorentzVector locPiPlusP4_Measured = dPiPlusWrapper->Get_P4_Measured(); TLorentzVector locPiMinusP4_Measured = dPiMinusWrapper->Get_P4_Measured(); TLorentzVector locProtonP4_Measured = dProtonWrapper->Get_P4_Measured(); //chi2PiPlus = dPiPlusWrapper->Get_Beta_Timing_Measured(); //chi2Prot = dProtonWrapper->Get_Beta_Timing_Measured(); inVector = locBeamP4_Measured + dTargetP4; outVector = locPiPlusP4_Measured + locPiMinusP4_Measured + locProtonP4_Measured; missingP = (inVector - outVector).P(); missingE = (inVector - outVector).E(); mimass_all = (inVector - outVector).M2(); mimassVec = inVector - locProtonP4_Measured; imassVec = locPiPlusP4_Measured + locPiMinusP4_Measured; mimassPipPimVec = inVector - locPiPlusP4_Measured - locPiMinusP4_Measured; mimassPipPim = mimassPipPimVec.M2(); mimassPipPVec = inVector - locPiPlusP4_Measured - locProtonP4_Measured; mimassPipP = mimassPipPVec.M2(); mimassPimPVec = inVector - locPiMinusP4_Measured - locProtonP4_Measured; mimassPimP = mimassPimPVec.M2(); mimass = mimassVec.M(); imass = imassVec.M(); kfitProb = TMath::Prob(dComboWrapper->Get_ChiSq_KinFit(),dComboWrapper->Get_NDF_KinFit()); pullCollection[0][0] = dComboWrapper->Get_Fundamental<Double_t>("PiPlus__Px_Pull"); pullCollection[0][1] = dComboWrapper->Get_Fundamental<Double_t>("PiPlus__Py_Pull"); pullCollection[0][2] = dComboWrapper->Get_Fundamental<Double_t>("PiPlus__Pz_Pull"); pullCollection[0][3] = dComboWrapper->Get_Fundamental<Double_t>("PiPlus__Vx_Pull"); pullCollection[0][4] = dComboWrapper->Get_Fundamental<Double_t>("PiPlus__Vy_Pull"); pullCollection[0][5] = dComboWrapper->Get_Fundamental<Double_t>("PiPlus__Vz_Pull"); pullCollection[1][0] = dComboWrapper->Get_Fundamental<Double_t>("PiMinus__Px_Pull"); pullCollection[1][1] = dComboWrapper->Get_Fundamental<Double_t>("PiMinus__Py_Pull"); pullCollection[1][2] = dComboWrapper->Get_Fundamental<Double_t>("PiMinus__Pz_Pull"); pullCollection[1][3] = dComboWrapper->Get_Fundamental<Double_t>("PiMinus__Vx_Pull"); pullCollection[1][4] = dComboWrapper->Get_Fundamental<Double_t>("PiMinus__Vy_Pull"); pullCollection[1][5] = dComboWrapper->Get_Fundamental<Double_t>("PiMinus__Vz_Pull"); pullCollection[2][0] = dComboWrapper->Get_Fundamental<Double_t>("Proton__Px_Pull"); pullCollection[2][1] = dComboWrapper->Get_Fundamental<Double_t>("Proton__Py_Pull"); pullCollection[2][2] = dComboWrapper->Get_Fundamental<Double_t>("Proton__Pz_Pull"); pullCollection[2][3] = dComboWrapper->Get_Fundamental<Double_t>("Proton__Vx_Pull"); pullCollection[2][4] = dComboWrapper->Get_Fundamental<Double_t>("Proton__Vy_Pull"); pullCollection[2][5] = dComboWrapper->Get_Fundamental<Double_t>("Proton__Vz_Pull"); //setPullElements(0,0,pullCollection[0][0]); /********************************************* COMBINE FOUR-MOMENTUM ********************************************/ // DO YOUR STUFF HERE // Combine 4-vectors TLorentzVector locMissingP4_Measured = locBeamP4_Measured + dTargetP4; locMissingP4_Measured -= locPiPlusP4_Measured + locPiMinusP4_Measured + locProtonP4_Measured; /******************************************** EXECUTE ANALYSIS ACTIONS *******************************************/ // Loop through the analysis actions, executing them in order for the active particle combo if(!Execute_Actions()) //if the active combo fails a cut, IsComboCutFlag automatically set continue; //if you manually execute any actions, and it fails a cut, be sure to call: //dComboWrapper->Set_IsComboCut(true); /**************************************** EXAMPLE: FILL CUSTOM OUTPUT BRANCHES **************************************/ /* TLorentzVector locMyComboP4(8.0, 7.0, 6.0, 5.0); //for arrays below: 2nd argument is value, 3rd is array index //NOTE: By filling here, AFTER the cuts above, some indices won't be updated (and will be whatever they were from the last event) //So, when you draw the branch, be sure to cut on "IsComboCut" to avoid these. dTreeInterface->Fill_Fundamental<Float_t>("my_combo_array", -2*loc_i, loc_i); dTreeInterface->Fill_TObject<TLorentzVector>("my_p4_array", locMyComboP4, loc_i); */ /**************************************** EXAMPLE: HISTOGRAM BEAM ENERGY *****************************************/ //Histogram beam energy (if haven't already) if(locUsedSoFar_BeamEnergy.find(locBeamID) == locUsedSoFar_BeamEnergy.end()) { locUsedSoFar_BeamEnergy.insert(locBeamID); } /************************************ EXAMPLE: HISTOGRAM MISSING MASS SQUARED ************************************/ //Missing Mass Squared double locMissingMassSquared = locMissingP4_Measured.M2(); //Uniqueness tracking: Build the map of particles used for the missing mass //For beam: Don't want to group with final-state photons. Instead use "Unknown" PID (not ideal, but it's easy). map<Particle_t, set<Int_t> > locUsedThisCombo_Topology; locUsedThisCombo_Topology[Unknown].insert(locBeamID); //beam locUsedThisCombo_Topology[PiPlus].insert(locPiPlusTrackID); locUsedThisCombo_Topology[PiMinus].insert(locPiMinusTrackID); locUsedThisCombo_Topology[Proton].insert(locProtonTrackID); if(locUsedSoFar_Topology.find(locUsedThisCombo_Topology) == locUsedSoFar_Topology.end()) { //unique missing mass combo: histogram it, and register this combo of particles //dHist_MissingMassSquared->Fill(locMissingMassSquared); locUsedSoFar_Topology.insert(locUsedThisCombo_Topology); usedTopology = true; }else usedTopology = false; if(usedTopology){ missingP_vs_missingE->Fill(missingE,missingP); EM_balance->Fill(missingP-TMath::Abs(missingE)); MMALL->Fill(mimass_all); MM_vs_IM->Fill(imass,mimass); probDist->Fill(kfitProb); //----------------------------------------------------------------------------- if(isInsideDM(missingP-TMath::Abs(missingE),0.0016,0.0106,2)){ //1st cut to reconstruct: gp->pi+pi- p: missing energy and missing momentum probDistCut->Fill(kfitProb); missingP_vs_missingE_Cut->Fill(missingE,missingP); MM_vs_IM_Cut->Fill(imass,mimass); EM_balance_Cut->Fill(missingP-TMath::Abs(missingE)); MMALL_Cut->Fill(mimass_all); //----------------------------------------------------------------------------- if(mimass_all > -0.005 && mimass_all < 0.005){ //2nd cut to reconstruct: gp->pi+pi- p: overall missing mass --> should be 0 probDistCut2->Fill(kfitProb); missingP_vs_missingE_Cut2->Fill(missingE,missingP); MM_vs_IM_Cut2->Fill(imass,mimass); EM_balance_Cut2->Fill(missingP-TMath::Abs(missingE)); MMALL_Cut2->Fill(mimass_all); //Angular INDEPENDENT investigation of pulls: //------------------------------------------------------------ for(Int_t a=0;a<3;a++){ for(Int_t b=0;b<6;b++){ Pulls_vs_Prob[a][b]->Fill(kfitProb,pullCollection[a][b]); } } //------------------------------------------------------------ fillAngularHists(locPiPlusP4_Measured,locPiMinusP4_Measured,locProtonP4_Measured,Theta_vs_phi_PiPlus,Theta_vs_phi_PiMinus,Theta_vs_phi_Prot); //Angular DEPENDENT investigation of pulls: fillPullHistsPiPlus(getTheta(locPiPlusP4,"deg"),getPhi(locPiPlusP4,"deg"),kfitProb); fillPullHistsPiMinus(getTheta(locPiMinusP4,"deg"),getPhi(locPiMinusP4,"deg"),kfitProb); fillPullHistsProt(getTheta(locProtonP4,"deg"),getPhi(locProtonP4,"deg"),kfitProb); } //----------------------------------------------------------------------------- } //----------------------------------------------------------------------------- } //E.g. Cut //if((locMissingMassSquared < -0.04) || (locMissingMassSquared > 0.04)) //{ // dComboWrapper->Set_IsComboCut(true); // continue; //} /****************************************** FILL FLAT TREE (IF DESIRED) ******************************************/ /* //FILL ANY CUSTOM BRANCHES FIRST!! Int_t locMyInt_Flat = 7; dFlatTreeInterface->Fill_Fundamental<Int_t>("flat_my_int", locMyInt_Flat); TLorentzVector locMyP4_Flat(4.0, 3.0, 2.0, 1.0); dFlatTreeInterface->Fill_TObject<TLorentzVector>("flat_my_p4", locMyP4_Flat); for(int loc_j = 0; loc_j < locMyInt_Flat; ++loc_j) { dFlatTreeInterface->Fill_Fundamental<Int_t>("flat_my_int_array", 3*loc_j, loc_j); //2nd argument = value, 3rd = array index TLorentzVector locMyComboP4_Flat(8.0, 7.0, 6.0, 5.0); dFlatTreeInterface->Fill_TObject<TLorentzVector>("flat_my_p4_array", locMyComboP4_Flat, loc_j); } */ //FILL FLAT TREE //Fill_FlatTree(); //for the active combo } // end of combo loop //FILL HISTOGRAMS: Num combos / events surviving actions Fill_NumCombosSurvivedHists(); /******************************************* LOOP OVER THROWN DATA (OPTIONAL) ***************************************/ /* //Thrown beam: just use directly if(dThrownBeam != NULL) double locEnergy = dThrownBeam->Get_P4().E(); //Loop over throwns for(UInt_t loc_i = 0; loc_i < Get_NumThrown(); ++loc_i) { //Set branch array indices corresponding to this particle dThrownWrapper->Set_ArrayIndex(loc_i); //Do stuff with the wrapper here ... } */ /****************************************** LOOP OVER OTHER ARRAYS (OPTIONAL) ***************************************/ /* //Loop over beam particles (note, only those appearing in combos are present) for(UInt_t loc_i = 0; loc_i < Get_NumBeam(); ++loc_i) { //Set branch array indices corresponding to this particle dBeamWrapper->Set_ArrayIndex(loc_i); //Do stuff with the wrapper here ... } //Loop over charged track hypotheses for(UInt_t loc_i = 0; loc_i < Get_NumChargedHypos(); ++loc_i) { //Set branch array indices corresponding to this particle dChargedHypoWrapper->Set_ArrayIndex(loc_i); //Do stuff with the wrapper here ... } //Loop over neutral particle hypotheses for(UInt_t loc_i = 0; loc_i < Get_NumNeutralHypos(); ++loc_i) { //Set branch array indices corresponding to this particle dNeutralHypoWrapper->Set_ArrayIndex(loc_i); //Do stuff with the wrapper here ... } */ /************************************ EXAMPLE: FILL CLONE OF TTREE HERE WITH CUTS APPLIED ************************************/ /* Bool_t locIsEventCut = true; for(UInt_t loc_i = 0; loc_i < Get_NumCombos(); ++loc_i) { //Set branch array indices for combo and all combo particles dComboWrapper->Set_ComboIndex(loc_i); // Is used to indicate when combos have been cut if(dComboWrapper->Get_IsComboCut()) continue; locIsEventCut = false; // At least one combo succeeded break; } if(!locIsEventCut && dOutputTreeFileName != "") Fill_OutputTree(); */ return kTRUE; }
void Arma::atirar(float theta, float time){ setX(cos(getTheta()*M_PI/180 )*time); setY(sin(getTheta()*M_PI/180 )*time); }
void changeSection(float *buf_x, float *buf_y, float *buf_l, float *buf_th){ *buf_x = getXCoo(); *buf_y = getYCoo(); *buf_l = getDistance(); *buf_th = getTheta( ); }