Commit 565079cc authored by flavigny's avatar flavigny
Browse files

* Adding Data an Physics class for RIBF PPAC (work in progress)

parent 3a883ca7
Pipeline #113993 passed with stages
in 19 minutes and 56 seconds
#ifndef BIGRIPSPPACVariables_H
#define BIGRIPSPPACVariables_H
/*****************************************************************************
* Copyright (C) 2009-2020 this file is part of the NPTool Project *
* *
* For the licensing terms see $NPTOOL/Licence/NPTool_Licence *
* For the list of contributors see $NPTOOL/Licence/Contributors *
*****************************************************************************/
/*****************************************************************************
* Original Author: Adrien MATTA contact address: matta@lpccaen.in2p3.fr *
* *
* Creation Date : October 2020 *
* Last update : *
*---------------------------------------------------------------------------*
* Decription: *
* This class hold SamuraiFDC0 treated data *
* *
*---------------------------------------------------------------------------*
* Comment: *
* *
* little class to index each of the DC wire *
* *
*****************************************************************************/
#include <iostream>
using namespace std;
class BigRIPSPPACVariables{
public:
BigRIPSPPACVariables(){};
~BigRIPSPPACVariables(){};
public:
std::vector<double> FTX1;
std::vector<double> FTX2;
std::vector<double> FTY1;
std::vector<double> FTY2;
std::vector<double> FTA;
void Clear(){
FTX1.clear();
FTX2.clear();
FTY1.clear();
FTY2.clear();
FTA.clear();
}
void Print(){
//cout << "XXXXXXXXXXXXXXXXXXXXXXXX PPAC Event XXXXXXXXXXXXXXXXX" << endl;
cout << "FTX1_Mult = " << FTX1.size();
for (UShort_t i = 0; i < FTX1.size(); i++){cout << "\tFTX1: " << FTX1[i] << endl;}
cout << "FTX2_Mult = " << FTX2.size();
for (UShort_t i = 0; i < FTX2.size(); i++){cout << "\tFTX2: " << FTX2[i] << endl;}
cout << "FTY1_Mult = " << FTY1.size();
for (UShort_t i = 0; i < FTY1.size(); i++){cout << "\tFTY1: " << FTY1[i] << endl;}
cout << "FTY2_Mult = " << FTY2.size();
for (UShort_t i = 0; i < FTY2.size(); i++){cout << "\tFTY2: " << FTY2[i] << endl;}
cout << "FTA_Mult = " << FTA.size();
for (UShort_t i = 0; i < FTA.size(); i++){cout << "\tFTA: " << FTA[i] << endl;}
}
bool HasTXs(){
if(FTX1.size()==1 && FTX2.size()==1){return true;}
else{return false;}
}
bool HasTYs(){
if(FTY1.size()==1 && FTY2.size()==1){return true;}
else{return false;}
}
bool HasTA(){
if(FTA.size()==1){return true;}
else{return false;}
}
bool HasEverything(){
if(FTX1.size()==1 && FTX2.size()==1 &&
FTY1.size()==1 && FTY2.size()==1 &&
FTA.size()==1){
return true;
}else{return false;}
}
/*
public:
void SetTX1(double value){TX1=value;}
void SetTX2(double value){TX2=value;}
void SetTY1(double value){TY1=value;}
void SetTY2(double value){TY2=value;}
void SetTA(double value){TA=value;}
int GetTX1Mult() const {return TX1.size();}
int const GetTX1(const unsigned int& i){return fPPAC_TX1[i];};
int GetTX2Mult() const {return fPPAC_TX2_ID.size();}
int const GetTX2(const unsigned int& i){return fPPAC_TX2[i];};
int GetTY1Mult() const {return fPPAC_TY1_ID.size();}
int const GetTY1(const unsigned int& i){return fPPAC_TY1[i];};
int GetTY2Mult() const {return fPPAC_TY2_ID.size();}
int const GetTY2(const unsigned int& i){return fPPAC_TY2[i];};
int GetTAMult() const {return fPPAC_TA_ID.size();}
int const GetTA(const unsigned int& i){return fPPAC_TA[i];};
double GetTX1(){return TX1;}
double GetTX2(){return TX2;}
double GetTY1(){return TY1;}
double GetTY2(){return TY2;}
double GetTA(){return TA;}
*/
};
#endif
add_custom_command(OUTPUT TBigRIPSPPACDataDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TBigRIPSPPACData.h TBigRIPSPPACDataDict.cxx TBigRIPSPPACData.rootmap libNPBigRIPS.dylib DEPENDS TBigRIPSPPACData.h)
add_custom_command(OUTPUT TBigRIPSPPACPhysicsDict.cxx COMMAND ${CMAKE_BINARY_DIR}/scripts/build_dict.sh TBigRIPSPPACPhysics.h TBigRIPSPPACPhysicsDict.cxx TBigRIPSPPACPhysics.rootmap libNPBigRIPS.dylib DEPENDS TBigRIPSPPACPhysics.h)
add_library(NPBigRIPS SHARED TBigRIPSPPACData.cxx TBigRIPSPPACDataDict.cxx TBigRIPSPPACPhysics.cxx TBigRIPSPPACPhysicsDict.cxx)
target_link_libraries(NPBigRIPS ${ROOT_LIBRARIES} NPCore NPTrackReconstruction)
install(FILES TBigRIPSPPACData.h TBigRIPSPPACPhysics.h DESTINATION ${CMAKE_INCLUDE_OUTPUT_DIRECTORY})
#include "TBigRIPSPPACData.h"
#include <iostream>
TBigRIPSPPACData::TBigRIPSPPACData(){};
TBigRIPSPPACData::~TBigRIPSPPACData(){};
/*
void TBigRIPSPPACData::SetData(const int& FP, const int& ID, const int& Edge, const int& value,const int& VariableType){
fPPAC_FP.push_back(FP);
fPPAC_ID.push_back(ID);
fPPAC_Edge.push_back(Edge);
switch(VariableType){
case 0: fPPAC_TX1.push_back(value); break;
case 1: fPPAC_TX2.push_back(value); break;
case 2: fPPAC_TY1.push_back(value); break;
case 3: fPPAC_TY2.push_back(value); break;
case 4: fPPAC_TA.push_back(value); break;
case 5: fPPAC_QX1.push_back(value); break;
case 6: fPPAC_QX2.push_back(value); break;
case 7: fPPAC_QY1.push_back(value); break;
case 8: fPPAC_QY2.push_back(value); break;
case 9: fPPAC_QA.push_back(value); break;
}
}
*/
////////////////////////////////////////////////////////////////////////////////
void TBigRIPSPPACData::Clear(){
// fPPAC_FP.clear();
// fPPAC_ID.clear();
// fPPAC_Edge.clear();
fPPAC_TX1.clear();
fPPAC_TX2.clear();
fPPAC_TY1.clear();
fPPAC_TY2.clear();
fPPAC_TA.clear();
fPPAC_QX1.clear();
fPPAC_QX2.clear();
fPPAC_QY1.clear();
fPPAC_QY2.clear();
fPPAC_QA.clear();
fPPAC_TX1_ID.clear();
fPPAC_TX2_ID.clear();
fPPAC_TY1_ID.clear();
fPPAC_TY2_ID.clear();
fPPAC_TA_ID.clear();
fPPAC_QX1_ID.clear();
fPPAC_QX2_ID.clear();
fPPAC_QY1_ID.clear();
fPPAC_QY2_ID.clear();
fPPAC_QA_ID.clear();
}
////////////////////////////////////////////////////////////////////////////////
void TBigRIPSPPACData::Print(){
using namespace std;
cout << " -- Event:" << endl;
//cout << " - Multiplicity: " << Mult() << endl;
}
////////////////////////////////////////////////////////////////////////////////
/*
unsigned int TBigRIPSPPACData::MultLayer(unsigned int det , unsigned int layer, int edge){
unsigned int mult=0;
unsigned int size = fDC_DetectorNbr.size();
for(unsigned int i = 0 ; i< size ; i++ ){
if(fDC_DetectorNbr[i]==det)
if(fDC_LayerNbr[i]==layer)
if(fDC_Edge[i]==edge && edge!=-1) // edge type is specified (0 or 1)
mult++;
else if(edge==-1)// edge type is not specified
mult++;
}
return mult;
}
////////////////////////////////////////////////////////////////////////////////
std::vector<int> TBigRIPSPPACData::GetWire(unsigned int det , unsigned int layer){
std::vector<int> wires;
unsigned int size = fDC_DetectorNbr.size();
for(unsigned int i = 0 ; i< size ; i++ ){
if(fDC_DetectorNbr[i]==det)
if(fDC_LayerNbr[i]==layer)
wires.push_back(fDC_WireNbr[i]);
}
return wires;
}
*/
ClassImp(TBigRIPSPPACData);
#ifndef TDCDATA_H
#define TDCDATA_H
#include "TObject.h"
#include <vector>
class TBigRIPSPPACData: public TObject{
public:
TBigRIPSPPACData();
~TBigRIPSPPACData();
private:
//std::vector<int> fPPAC_FP; //focal plane
//std::vector<int> fPPAC_ID; //specific ID
//std::vector<int> fPPAC_Edge;
std::vector<int> fPPAC_TX1;
std::vector<int> fPPAC_TX2;
std::vector<int> fPPAC_TY1;
std::vector<int> fPPAC_TY2;
std::vector<int> fPPAC_TA;
std::vector<int> fPPAC_QX1;
std::vector<int> fPPAC_QX2;
std::vector<int> fPPAC_QY1;
std::vector<int> fPPAC_QY2;
std::vector<int> fPPAC_QA;
std::vector<int> fPPAC_TX1_ID;
std::vector<int> fPPAC_TX2_ID;
std::vector<int> fPPAC_TY1_ID;
std::vector<int> fPPAC_TY2_ID;
std::vector<int> fPPAC_TA_ID;
std::vector<int> fPPAC_QX1_ID;
std::vector<int> fPPAC_QX2_ID;
std::vector<int> fPPAC_QY1_ID;
std::vector<int> fPPAC_QY2_ID;
std::vector<int> fPPAC_QA_ID;
/*
enum ChannelType{
TX1,
TX2,
TY1,
TY2,
TA,
QX1,
QX2,
QY1,
QY2,
QA
};//should match with the Channel Type define in Unpacker
*/
public:
void Clear();
void Print();
void Clear(const Option_t*) {};
void Dump() const{};
public:
//void SetData(const int& FP, const int& ID, const int& Edge, const int& Value,const int& VariableType);
//unsigned int Mult(){return fPPAC_DetectorNbr.size();};
//unsigned int MultLayer(unsigned int det , unsigned int layer, int edge=-1);
//int const GetID(const unsigned int& i){return fPPAC_ID[i];};
//int const GetFP(const unsigned int& i){return fPPAC_FP[i];};
//int const GetEdge(const unsigned int& i){return fPPAC_Edge[i];};
/*
double const GetTX2(const unsigned int& i){return fPPAC_TX2[i];};
double const GetTY1(const unsigned int& i){return fPPAC_TY1[i];};
double const GetTY2(const unsigned int& i){return fPPAC_TY2[i];};
double const GetTA(const unsigned int& i){return fPPAC_TA[i];};
double const GetQX1(const unsigned int& i){return fPPAC_QX1[i];};
double const GetQX2(const unsigned int& i){return fPPAC_QX2[i];};
double const GetQY1(const unsigned int& i){return fPPAC_QY1[i];};
double const GetQY2(const unsigned int& i){return fPPAC_QY2[i];};
double const GetQA(const unsigned int& i){return fPPAC_QA[i];};
*/
//void SetID(const int& i){fPPAC_ID.push_back(i);}
//void SetFP(const int& i){fPPAC_FP.push_back(i);}
//void SetEdge(const int& i){fPPAC_Edge.push_back(i);}
void SetTX1(const int& T, const int& ID){fPPAC_TX1.push_back(T);fPPAC_TX1_ID.push_back(ID);}
void SetTX2(const int& T, const int& ID){fPPAC_TX2.push_back(T);fPPAC_TX2_ID.push_back(ID);}
void SetTY1(const int& T, const int& ID){fPPAC_TY1.push_back(T);fPPAC_TY1_ID.push_back(ID);}
void SetTY2(const int& T, const int& ID){fPPAC_TY2.push_back(T);fPPAC_TY2_ID.push_back(ID);}
void SetTA(const int& T, const int& ID){fPPAC_TA.push_back(T);fPPAC_TA_ID.push_back(ID);}
void SetQX1(const int& Q, const int& ID){fPPAC_QX1.push_back(Q);fPPAC_TX1_ID.push_back(ID);}
void SetQX2(const int& Q, const int& ID){fPPAC_QX2.push_back(Q);fPPAC_TX2_ID.push_back(ID);}
void SetQY1(const int& Q, const int& ID){fPPAC_QY1.push_back(Q);fPPAC_TY1_ID.push_back(ID);}
void SetQY2(const int& Q, const int& ID){fPPAC_QY2.push_back(Q);fPPAC_TY2_ID.push_back(ID);}
void SetQA(const int& Q, const int& ID){fPPAC_QA.push_back(Q);fPPAC_TA_ID.push_back(ID);}
int GetTX1Mult() const {return fPPAC_TX1_ID.size();}
int const GetTX1(const unsigned int& i){return fPPAC_TX1[i];};
int const GetTX1ID(const unsigned int& i){return fPPAC_TX1_ID[i];};
int GetTX2Mult() const {return fPPAC_TX2_ID.size();}
int const GetTX2(const unsigned int& i){return fPPAC_TX2[i];};
int const GetTX2ID(const unsigned int& i){return fPPAC_TX2_ID[i];};
int GetTY1Mult() const {return fPPAC_TY1_ID.size();}
int const GetTY1(const unsigned int& i){return fPPAC_TY1[i];};
int const GetTY1ID(const unsigned int& i){return fPPAC_TY1_ID[i];};
int GetTY2Mult() const {return fPPAC_TY2_ID.size();}
int const GetTY2(const unsigned int& i){return fPPAC_TY2[i];};
int const GetTY2ID(const unsigned int& i){return fPPAC_TY2_ID[i];};
int GetTAMult() const {return fPPAC_TA_ID.size();}
int const GetTA(const unsigned int& i){return fPPAC_TA[i];};
int const GetTAID(const unsigned int& i){return fPPAC_TA_ID[i];};
int GetQX1Mult() const {return fPPAC_QX1_ID.size();}
int const GetQX1(const unsigned int& i){return fPPAC_QX1[i];};
int const GetQX1ID(const unsigned int& i){return fPPAC_QX1_ID[i];};
int GetQX2Mult() const {return fPPAC_QX2_ID.size();}
int const GetQX2(const unsigned int& i){return fPPAC_QX2[i];};
int const GetQX2ID(const unsigned int& i){return fPPAC_QX2_ID[i];};
int GetQY1Mult() const {return fPPAC_QY1_ID.size();}
int const GetQY1(const unsigned int& i){return fPPAC_QY1[i];};
int const GetQY1ID(const unsigned int& i){return fPPAC_QY1_ID[i];};
int GetQY2Mult() const {return fPPAC_QY2_ID.size();}
int const GetQY2(const unsigned int& i){return fPPAC_QY2[i];};
int const GetQY2ID(const unsigned int& i){return fPPAC_QY2_ID[i];};
int GetQAMult() const {return fPPAC_QA_ID.size();}
int const GetQA(const unsigned int& i){return fPPAC_QA[i];};
int const GetQAID(const unsigned int& i){return fPPAC_QA_ID[i];};
ClassDef(TBigRIPSPPACData,1);
};
#endif
/*****************************************************************************
* Copyright (C) 2009-2016 this file is part of the NPTool Project *
* *
* For the licensing terms see $NPTOOL/Licence/NPTool_Licence *
* For the list of contributors see $NPTOOL/Licence/Contributors *
*****************************************************************************/
/*****************************************************************************
* Original Author: F, Flavigny contact address: flavigny@lpccaen.in2p3.fr *
* *
* Creation Date : April 2021 *
* Last update : *
*---------------------------------------------------------------------------*
* Decription: *
* This class hold RIBF PPAC treated data *
* *
*---------------------------------------------------------------------------*
* Comment: *
* *
*****************************************************************************/
#include "TBigRIPSPPACPhysics.h"
// STL
#include <sstream>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <limits>
// NPL
#include "RootInput.h"
#include "RootOutput.h"
#include "TAsciiFile.h"
#include "NPOptionManager.h"
#include "NPDetectorFactory.h"
#include "NPSystemOfUnits.h"
// ROOT
using namespace NPUNITS;
///////////////////////////////////////////////////////////////////////////
ClassImp(TBigRIPSPPACPhysics)
///////////////////////////////////////////////////////////////////////////
TBigRIPSPPACPhysics::TBigRIPSPPACPhysics(){
m_EventData = new TBigRIPSPPACData ;
m_PreTreatedData = new TBigRIPSPPACData ;
m_EventPhysics = this ;
//m_Spectra = NULL;
}
///////////////////////////////////////////////////////////////////////////
void TBigRIPSPPACPhysics::BuildSimplePhysicalEvent(){
BuildPhysicalEvent();
}
///////////////////////////////////////////////////////////////////////////
void TBigRIPSPPACPhysics::BuildPhysicalEvent(){
PreTreat();
return;
}
///////////////////////////////////////////////////////////////////////////
void TBigRIPSPPACPhysics::PreTreat(){
ClearPreTreatedData();
//static map<std::pair<int,int>, std::vector<int> > data ;
static map<int, BigRIPSPPACVariables > Fdata ;
//static map<std::pair<int,int>, bool > multiHit ;
//pair of detector ID and variable type (TX1,TX2,TY1,TY2,TA)=(0,1,2,3,4)
std::pair<unsigned int, double> pair_id_type;
int id, TimeRaw;
//pair_id_type.second = 0; //TX1
unsigned int sizeTX1 = m_EventData->GetTX1Mult();
for(unsigned int i = 0 ; i < sizeTX1 ; i++){
id = m_EventData->GetTX1ID(i);
TimeRaw = m_EventData->GetTX1(i);
if(TimeRaw>RawLowerLimit[id] && TimeRaw<RawUpperLimit[id]){
/*
pair_id_type.first = id;
if(data[pair_id_type].size()==0){
data[pair_id_type].push_back(TimeRaw);
}else {
multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
*/
if(Fdata[id].FTX1.size()==0){
Fdata[id].FTX1.push_back(TimeRaw*ch2ns_TX1[id]);
}else {
// multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
}
}
// pair_id_type.second = 1; //TX2
unsigned int sizeTX2 = m_EventData->GetTX2Mult();
for(unsigned int i = 0 ; i < sizeTX2 ; i++){
id = m_EventData->GetTX2ID(i);
TimeRaw = m_EventData->GetTX2(i);
if(TimeRaw>RawLowerLimit[id] && TimeRaw<RawUpperLimit[id]){
/*
pair_id_type.first = id;
if(data[pair_id_type].size()==0){
data[pair_id_type].push_back(TimeRaw);
}else {
multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
*/
if(Fdata[id].FTX2.size()==0){
Fdata[id].FTX2.push_back(TimeRaw*ch2ns_TX2[id]);
}else {
// multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
}
}
// pair_id_type.second = 2; //TY1
unsigned int sizeTY1 = m_EventData->GetTY1Mult();
for(unsigned int i = 0 ; i < sizeTY1 ; i++){
id = m_EventData->GetTY1ID(i);
TimeRaw = m_EventData->GetTY1(i);
if(TimeRaw>RawLowerLimit[id] && TimeRaw<RawUpperLimit[id]){
/*
pair_id_type.first = id;
if(data[pair_id_type].size()==0){
data[pair_id_type].push_back(TimeRaw);
}else {
multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
*/
if(Fdata[id].FTY1.size()==0){
Fdata[id].FTY1.push_back(TimeRaw*ch2ns_TY1[id]);
}else {
// multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
}
}
// pair_id_type.second = 3; //TY2
unsigned int sizeTY2 = m_EventData->GetTY2Mult();
for(unsigned int i = 0 ; i < sizeTY2 ; i++){
id = m_EventData->GetTY2ID(i);
TimeRaw = m_EventData->GetTY2(i);
if(TimeRaw>RawLowerLimit[id] && TimeRaw<RawUpperLimit[id]){
/*
pair_id_type.first = id;
if(data[pair_id_type].size()==0){
data[pair_id_type].push_back(TimeRaw);
}else {
multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
*/
if(Fdata[id].FTY2.size()==0){
Fdata[id].FTY2.push_back(TimeRaw*ch2ns_TY2[id]);
}else {
// multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
}
}
// pair_id_type.second = 4; //TA
unsigned int sizeTA = m_EventData->GetTAMult();
for(unsigned int i = 0 ; i < sizeTA ; i++){
id = m_EventData->GetTAID(i);
TimeRaw = m_EventData->GetTA(i);
if(TimeRaw>RawLowerLimit[id] && TimeRaw<RawUpperLimit[id]){
/*
pair_id_type.first = id;
if(data[pair_id_type].size()==0){
data[pair_id_type].push_back(TimeRaw);
}else {
multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
*/
if(Fdata[id].FTA.size()==0){
Fdata[id].FTA.push_back(TimeRaw*ch2ns_TA[id]);
}else {
// multiHit[pair_id_type]=true; //multiple value for same TDC ch.
}
}
}
/*
for(auto it = data.begin();it!=data.end();++it){
pair_id_type = it->first;
cout<< "ID:"<<pair_id_type.first<<"\tType:"<<pair_id_type.second<<" \tT:"<<data[pair_id_type][0]<<endl;
}
*/
int j=0;
BigRIPSPPACVariables toto;
for(auto it = Fdata.begin();it!=Fdata.end();++it){
id = it->first;
ID.push_back(id);
FP.push_back(FPL[id]);
toto.Clear();
toto = it->second;
//cout<< "ID:"<<id<<endl;
//cout<< "ch2nsX1:"<<ch2ns_TX1[id]<<endl;
//cout<< "ch2nsX2:"<<ch2ns_TX2[id]<<endl;
//cout<< "ch2nsY1:"<<ch2ns_TY1[id]<<endl;
//cout<< "ch2nsY2:"<<ch2ns_TY2[id]<<endl;
//cout<< "ch2nsA:"<<ch2ns_TA[id]<<endl;
//toto.Print();
for (int i=0; i<toto.FTX1.size(); i++) TX1.push_back(toto.FTX1[i]);
for (int i=0; i<toto.FTX2.size(); i++) TX2.push_back(toto.FTX2[i]);
for (int i=0; i<toto.FTY1.size(); i++) TY1.push_back(toto.FTY1[i]);
for (int i=0; i<toto.FTY2.size(); i++) TY2.push_back(toto.FTY2[i]);
for (int i=0; i<toto.FTA.size(); i++) TA.push_back(toto.FTA[i]);
//TX1=toto.FTX1;
//TX2=toto.FTX2;
//TY1=toto.FTY1;
//TY2=toto.FTY2;
//TA=toto.FTA;
//if(toto.HasTXs()) {TDiffX.push_back(TX1[j]-TX2[j]);}
if(toto.HasTXs()) {TDiffX.push_back(toto.FTX1[0]-toto.FTX2[0]);}
else {TDiffX.push_back(-99999);}
//if(toto.HasTXs() && toto.HasTA()) {TSumX.push_back(TX1[j]+TX2[j]-2*TA[j]);}
if(toto.HasTXs() && toto.HasTA()) {TSumX.push_back(toto.FTX1[0]+toto.FTX2[0]-2*toto.FTA[0]);}
else {TSumX.push_back(-99999);}
//if(toto.HasTYs()) {TDiffY.push_back(TY1[j]-TY2[j]);}
if(toto.HasTYs()) {TDiffY.push_back(toto.FTY1[0]-toto.FTY2[0]);}
else {TDiffY.push_back(-99999);}
//if(toto.HasTYs() && toto.HasTA()) {TSumY.push_back(TY1[j]+TY2[j]-2*TA[j]);}
if(toto.HasTYs() && toto.HasTA()) {TSumY.push_back(toto.FTY1[0]+toto.FTY2[0]-2*toto.FTA[0]);}
else {TSumY.push_back(-99999);}
j++;
}
//Print();
Fdata.clear();
return;
}
///////////////////////////////////////////////////////////////////////////
void TBigRIPSPPACPhysics::Clear(){
TX1.clear();
TX2.clear();
TY1.clear();</