diff --git a/NPLib/Core/NPInputParser.cxx b/NPLib/Core/NPInputParser.cxx
index 9680ce502e2a091692278f26df6e8e892d3148df..87f6f348ec3f1f17c2c879dd1338876969d3a3fa 100644
--- a/NPLib/Core/NPInputParser.cxx
+++ b/NPLib/Core/NPInputParser.cxx
@@ -1,346 +1,348 @@
-#include"NPInputParser.h"
-#include"NPSystemOfUnits.h"
-#include"NPOptionManager.h"
-#include"NPCore.h"
-#include<sstream>
-#include<iostream>
-#include<fstream>
-#include<algorithm>
+#include "NPInputParser.h"
+#include "NPCore.h"
+#include "NPOptionManager.h"
+#include "NPSystemOfUnits.h"
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <sstream>
////////////////////////////////////////////////////////////////////////////////
-NPL::InputBlock* NPL::InputBlock::Copy(){
+NPL::InputBlock* NPL::InputBlock::Copy() {
NPL::InputBlock* res = new NPL::InputBlock();
res->m_Level = this->m_Level;
res->m_MainToken = this->m_MainToken;
res->m_MainValue = this->m_MainValue;
res->m_Token = this->m_Token;
- res->m_Value = this->m_Value;
+ res->m_Value = this->m_Value;
return res;
}
-
////////////////////////////////////////////////////////////////////////////////
-std::string NPL::StripSpaces(std::string line){
+std::string NPL::StripSpaces(std::string line) {
// Remove preceding spaces
- while(*line.begin()==' ')
- line = line.substr(1,line.length());
+ while (*line.begin() == ' ')
+ line = line.substr(1, line.length());
// Remove trailing spaces
- if(line.length()>0)
- while(*line.rbegin()==' ')
- line = line.substr(0,line.length()-1);
+ if (line.length() > 0)
+ while (*line.rbegin() == ' ')
+ line = line.substr(0, line.length() - 1);
// Remove preceding tabs
- while(*line.begin()=='\t')
- line = line.substr(1,line.length());
+ while (*line.begin() == '\t')
+ line = line.substr(1, line.length());
// Remove trailing tabs
- if(line.length()>0)
- while(*line.rbegin()=='\t')
- line = line.substr(0,line.length()-1);
+ if (line.length() > 0)
+ while (*line.rbegin() == '\t')
+ line = line.substr(0, line.length() - 1);
return line;
-
}
////////////////////////////////////////////////////////////////////////////////
-unsigned int NPL::GetLevel(std::string line){
- unsigned int level = 0 ;
- if(line.length()==0)
+unsigned int NPL::GetLevel(std::string line) {
+ unsigned int level = 0;
+ if (line.length() == 0)
return 1000;
- for(unsigned int i = 0 ; i < line.length() ; i++){
- if(line.compare(i,1," ")==0)
+ for (unsigned int i = 0; i < line.length(); i++) {
+ if (line.compare(i, 1, " ") == 0)
level++;
- else
+ else
break;
}
- return level;
+ return level;
}
////////////////////////////////////////////////////////////////////////////////
-std::string NPL::ToLower(std::string line){
+std::string NPL::ToLower(std::string line) {
std::transform(line.begin(), line.end(), line.begin(), ::tolower);
return line;
}
////////////////////////////////////////////////////////////////////////////////
-NPL::InputBlock::InputBlock(std::string line){
- m_Level = GetLevel(line);
- m_MainToken = StripSpaces(ExtractToken(line," "));
- m_MainValue = StripSpaces(ExtractValue(line," "));
+NPL::InputBlock::InputBlock(std::string line) {
+ m_Level = GetLevel(line);
+ m_MainToken = StripSpaces(ExtractToken(line, " "));
+ m_MainValue = StripSpaces(ExtractValue(line, " "));
}
////////////////////////////////////////////////////////////////////////////////
-std::string NPL::InputBlock::ExtractToken(std::string line,std::string separator){
+std::string NPL::InputBlock::ExtractToken(std::string line, std::string separator) {
// Find the separator
- if(separator=="")
+ if (separator == "")
separator = NPL::token_separator;
std::size_t pos = line.find(separator.c_str());
- return line.substr (0,pos);
+ return line.substr(0, pos);
}
////////////////////////////////////////////////////////////////////////////////
-std::string NPL::InputBlock::ExtractValue(std::string line,std::string separator){
+std::string NPL::InputBlock::ExtractValue(std::string line, std::string separator) {
// Find the separator
- if(separator=="")
+ if (separator == "")
separator = NPL::token_separator;
std::size_t pos = line.find(separator.c_str());
- if(pos!=std::string::npos)
- return line.substr (pos+1);
+ if (pos != std::string::npos)
+ return line.substr(pos + 1);
else
return "";
}
////////////////////////////////////////////////////////////////////////////////
-void NPL::InputBlock::AddLine(std::string line){
+void NPL::InputBlock::AddLine(std::string line) {
m_Token.push_back(ToLower(StripSpaces(ExtractToken(line))));
m_Value.push_back(StripSpaces(ExtractValue(line)));
- m_Lines.push_back(StripSpaces(line));
+ m_Lines.push_back(StripSpaces(line));
}
////////////////////////////////////////////////////////////////////////////////
-void NPL::InputBlock::Dump(){
+void NPL::InputBlock::Dump() {
std::cout << "//////////// Block ////////////" << std::endl;
- std::cout << " * Main Token: " << m_MainToken << std::endl ;
- std::cout << " * Main Value: " << m_MainValue << std::endl;
+ std::cout << " * Main Token: " << m_MainToken << std::endl;
+ std::cout << " * Main Value: " << m_MainValue << std::endl;
std::cout << " * Number of Line: " << GetSize() << std::endl;
- for(unsigned int i = 0 ; i < GetSize() ; i++)
- std::cout << " - " << i+1 << " " << m_Token[i] << ": " << m_Value[i] << std::endl;
+ for (unsigned int i = 0; i < GetSize(); i++)
+ std::cout << " - " << i + 1 << " " << m_Token[i] << ": " << m_Value[i] << std::endl;
}
////////////////////////////////////////////////////////////////////////////////
-bool NPL::InputBlock::HasTokenList(std::vector<std::string> Token){
- if(m_Token.size()==0)
+bool NPL::InputBlock::HasTokenList(std::vector<std::string> Token) {
+ if (m_Token.size() == 0)
return false;
bool res = true;
- for(unsigned int i = 0 ; i < Token.size() ; i++)
+ for (unsigned int i = 0; i < Token.size(); i++)
res = res && HasToken(Token[i]);
return res;
}
////////////////////////////////////////////////////////////////////////////////
-bool NPL::InputBlock::HasToken(std::string Token){
- for(unsigned int i = 0 ; i < m_Token.size() ; i++){
- if(m_Token[i] == ToLower(Token)){
+std::vector<std::string> NPL::InputBlock::GetMissingToken(std::vector<std::string> Token) {
+ std::vector<std::string> missing;
+ for (unsigned int i = 0; i < Token.size(); i++) {
+ if (!HasToken(Token[i]))
+ missing.push_back(Token[i]);
+ }
+ return missing;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool NPL::InputBlock::HasToken(std::string Token) {
+ for (unsigned int i = 0; i < m_Token.size(); i++) {
+ if (m_Token[i] == ToLower(Token)) {
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
-std::string NPL::InputBlock::GetValue(std::string Token){
- for(unsigned int i = 0 ; i < m_Token.size() ; i++){
- if(m_Token[i]==ToLower(Token))
+std::string NPL::InputBlock::GetValue(std::string Token) {
+ for (unsigned int i = 0; i < m_Token.size(); i++) {
+ if (m_Token[i] == ToLower(Token))
return m_Value[i];
}
return "";
-
}
////////////////////////////////////////////////////////////////////////////////
-double NPL::InputBlock::GetDouble(std::string Token,std::string default_unit){
- int verbose = 1; //NPOptionManager::getInstance()->GetVerboseLevel();
+double NPL::InputBlock::GetDouble(std::string Token, std::string default_unit) {
+ int verbose = 1; // NPOptionManager::getInstance()->GetVerboseLevel();
std::stringstream iss(GetValue(Token));
double val;
std::string unit;
- iss >> val >> unit ;
- if(unit==""){
- if(default_unit!="void")
- std::cout <<"WARNING: Using default units for token " << Token << std::endl;
- val = ApplyUnit(val,default_unit);
+ iss >> val >> unit;
+ if (unit == "") {
+ if (default_unit != "void")
+ std::cout << "WARNING: Using default units for token " << Token << std::endl;
+ val = ApplyUnit(val, default_unit);
}
- else{
- val = ApplyUnit(val,unit);
+ else {
+ val = ApplyUnit(val, unit);
}
- if(verbose)
- printf(" %s (%s): %.4f\n",Token.c_str(),default_unit.c_str(), val/ApplyUnit(1,default_unit));
-// std::cout << " " << Token << " (" <<default_unit << "): " << val/ApplyUnit(1,default_unit) <<std::endl;
+ if (verbose)
+ printf(" %s (%s): %.4f\n", Token.c_str(), default_unit.c_str(), val / ApplyUnit(1, default_unit));
+ // std::cout << " " << Token << " (" <<default_unit << "): " << val/ApplyUnit(1,default_unit) <<std::endl;
- return val;
+ return val;
}
////////////////////////////////////////////////////////////////////////////////
-int NPL::InputBlock::GetInt(std::string Token){
- int verbose = 1;//NPOptionManager::getInstance()->GetVerboseLevel();
+int NPL::InputBlock::GetInt(std::string Token) {
+ int verbose = 1; // NPOptionManager::getInstance()->GetVerboseLevel();
std::stringstream iss(GetValue(Token));
int val;
- iss >> val ;
-
- if(verbose)
- printf(" %s: %d\n",Token.c_str(),val);
- // std::cout << " " << Token << ": " << val <<std::endl;
+ iss >> val;
+ if (verbose)
+ printf(" %s: %d\n", Token.c_str(), val);
+ // std::cout << " " << Token << ": " << val <<std::endl;
- return val;
+ return val;
}
////////////////////////////////////////////////////////////////////////////////
-std::string NPL::InputBlock::GetString(std::string Token){
- int verbose = 1;//NPOptionManager::getInstance()->GetVerboseLevel();
- if(verbose)
- printf(" %s: %s\n",Token.c_str(),GetValue(Token).c_str());
-// std::cout << " " << Token << ": " << GetValue(Token) << std::endl;
+std::string NPL::InputBlock::GetString(std::string Token) {
+ int verbose = 1; // NPOptionManager::getInstance()->GetVerboseLevel();
+ if (verbose)
+ printf(" %s: %s\n", Token.c_str(), GetValue(Token).c_str());
+ // std::cout << " " << Token << ": " << GetValue(Token) << std::endl;
return GetValue(Token);
}
////////////////////////////////////////////////////////////////////////////////
-TVector3 NPL::InputBlock::GetTVector3(std::string Token,std::string default_unit){
- int verbose = 1; //NPOptionManager::getInstance()->GetVerboseLevel();
+TVector3 NPL::InputBlock::GetTVector3(std::string Token, std::string default_unit) {
+ int verbose = 1; // NPOptionManager::getInstance()->GetVerboseLevel();
std::stringstream iss(GetValue(Token));
- double x,y,z;
+ double x, y, z;
std::string unit;
- iss >> x >> y >> z >> unit ;
- if(unit==""){
- if(default_unit!="void")
- std::cout <<"WARNING: Using default units for token " << Token << std::endl;
- x = ApplyUnit(x,default_unit);
- y = ApplyUnit(y,default_unit);
- z = ApplyUnit(z,default_unit);
- }
- else{
- x = ApplyUnit(x,unit);
- y = ApplyUnit(y,unit);
- z = ApplyUnit(z,unit);
- }
-
- if(verbose)
-
- printf(" %s (%s): (%.4f;%.4f;%.4f)\n",Token.c_str(),default_unit.c_str(), x/ApplyUnit(1,default_unit),y/ApplyUnit(1,default_unit),z/ApplyUnit(1,default_unit));
-// std::cout << " " << Token << " (" <<default_unit << "): ("
-// << x/ApplyUnit(1,default_unit) << " ; "
-// << y/ApplyUnit(1,default_unit) << " ; "
-// << z/ApplyUnit(1,default_unit) << ")" << std::endl;
-
-
- return TVector3(x,y,z);
+ iss >> x >> y >> z >> unit;
+ if (unit == "") {
+ if (default_unit != "void")
+ std::cout << "WARNING: Using default units for token " << Token << std::endl;
+ x = ApplyUnit(x, default_unit);
+ y = ApplyUnit(y, default_unit);
+ z = ApplyUnit(z, default_unit);
+ }
+ else {
+ x = ApplyUnit(x, unit);
+ y = ApplyUnit(y, unit);
+ z = ApplyUnit(z, unit);
+ }
+
+ if (verbose)
+
+ printf(" %s (%s): (%.4f;%.4f;%.4f)\n", Token.c_str(), default_unit.c_str(), x / ApplyUnit(1, default_unit),
+ y / ApplyUnit(1, default_unit), z / ApplyUnit(1, default_unit));
+ // std::cout << " " << Token << " (" <<default_unit << "): ("
+ // << x/ApplyUnit(1,default_unit) << " ; "
+ // << y/ApplyUnit(1,default_unit) << " ; "
+ // << z/ApplyUnit(1,default_unit) << ")" << std::endl;
+
+ return TVector3(x, y, z);
}
////////////////////////////////////////////////////////////////////////////////
-std::vector<std::string> NPL::InputBlock::GetVectorString(std::string Token){
- int verbose = 1 ; //NPOptionManager::getInstance()->GetVerboseLevel();
+std::vector<std::string> NPL::InputBlock::GetVectorString(std::string Token) {
+ int verbose = 1; // NPOptionManager::getInstance()->GetVerboseLevel();
std::stringstream iss(GetValue(Token));
std::vector<std::string> val;
std::string buffer;
- while(iss>>buffer)
+ while (iss >> buffer)
val.push_back(buffer);
+ if (verbose) {
+ printf(" %s: ", Token.c_str());
+ // std::cout << " " << Token << ": ";
+ for (unsigned int i = 0; i < val.size(); i++)
+ printf("%s ", val[i].c_str());
+ // std::cout << val[i] << " " ;
- if(verbose){
- printf(" %s: ",Token.c_str());
- //std::cout << " " << Token << ": ";
- for(unsigned int i = 0 ; i < val.size() ; i++)
- printf("%s ",val[i].c_str());
- //std::cout << val[i] << " " ;
-
printf("\n");
- //std::cout << std::endl;
-
+ // std::cout << std::endl;
}
- return val;
+ return val;
}
////////////////////////////////////////////////////////////////////////////////
-std::vector<double> NPL::InputBlock::GetVectorDouble(std::string Token,std::string default_unit){
- int verbose = 1 ; // NPOptionManager::getInstance()->GetVerboseLevel();
+std::vector<double> NPL::InputBlock::GetVectorDouble(std::string Token, std::string default_unit) {
+ int verbose = 1; // NPOptionManager::getInstance()->GetVerboseLevel();
std::stringstream iss(GetValue(Token));
std::vector<double> val;
double buffer;
- while(iss>>buffer)
+ while (iss >> buffer)
val.push_back(buffer);
- // Try to read the unit
+ // Try to read the unit
iss.clear();
std::string unit;
- iss>>unit;
+ iss >> unit;
- if(unit==""){
- if(default_unit!="void")
- std::cout <<"WARNING: Using default units for token " << Token << std::endl;
- for(unsigned int i = 0 ; i < val.size() ; i++)
- val[i]=ApplyUnit(val[i],default_unit);
+ if (unit == "") {
+ if (default_unit != "void")
+ std::cout << "WARNING: Using default units for token " << Token << std::endl;
+ for (unsigned int i = 0; i < val.size(); i++)
+ val[i] = ApplyUnit(val[i], default_unit);
}
- else{
- for(unsigned int i = 0 ; i < val.size() ; i++)
- val[i]=ApplyUnit(val[i],unit);
+ else {
+ for (unsigned int i = 0; i < val.size(); i++)
+ val[i] = ApplyUnit(val[i], unit);
}
- if(verbose){
- printf(" %s (%s): ",Token.c_str(),default_unit.c_str());
- //std::cout << " " << Token << " (" << default_unit << "): ";
- for(unsigned int i = 0 ; i < val.size() ; i++)
- printf("%f ",val[i]/ApplyUnit(1,default_unit) );
- //std::cout << val[i]/ApplyUnit(1,default_unit) << " " ;
+ if (verbose) {
+ printf(" %s (%s): ", Token.c_str(), default_unit.c_str());
+ // std::cout << " " << Token << " (" << default_unit << "): ";
+ for (unsigned int i = 0; i < val.size(); i++)
+ printf("%f ", val[i] / ApplyUnit(1, default_unit));
+ // std::cout << val[i]/ApplyUnit(1,default_unit) << " " ;
printf("\n");
- //std::cout << std::endl;
+ // std::cout << std::endl;
}
- return val;
+ return val;
}
////////////////////////////////////////////////////////////////////////////////
-std::vector<int> NPL::InputBlock::GetVectorInt(std::string Token){
- int verbose = 1;// NPOptionManager::getInstance()->GetVerboseLevel();
+std::vector<int> NPL::InputBlock::GetVectorInt(std::string Token) {
+ int verbose = 1; // NPOptionManager::getInstance()->GetVerboseLevel();
std::stringstream iss(GetValue(Token));
std::vector<int> val;
int buffer;
- while(iss>>buffer)
+ while (iss >> buffer)
val.push_back(buffer);
- if(verbose){
- printf(" %s: ",Token.c_str());
- //std::cout << " " << Token << ": ";
- for(unsigned int i = 0 ; i < val.size() ; i++)
- printf(" %d: ",val[i]);
+ if (verbose) {
+ printf(" %s: ", Token.c_str());
+ // std::cout << " " << Token << ": ";
+ for (unsigned int i = 0; i < val.size(); i++)
+ printf(" %d: ", val[i]);
// std::cout << val[i] << " " ;
- std::cout << std::endl;
+ std::cout << std::endl;
}
-
- return val;
+ return val;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
-void NPL::InputParser::Dump(){
- for(unsigned int i = 0 ; i < m_Block.size() ; i++)
+void NPL::InputParser::Dump() {
+ for (unsigned int i = 0; i < m_Block.size(); i++)
m_Block[i]->Dump();
}
////////////////////////////////////////////////////////////////////////////////
-bool NPL::InputParser::IsNotComment(std::string line){
+bool NPL::InputParser::IsNotComment(std::string line) {
line = StripSpaces(line);
- if(line.length()==0)
+ if (line.length() == 0)
return false;
std::size_t pos = line.find("%");
- if(pos==std::string::npos)
+ if (pos == std::string::npos)
return true;
else
return false;
}
////////////////////////////////////////////////////////////////////////////////
-std::vector<NPL::InputBlock*> NPL::InputParser::GetAllBlocksWithToken(std::string Token){
+std::vector<NPL::InputBlock*> NPL::InputParser::GetAllBlocksWithToken(std::string Token) {
std::vector<NPL::InputBlock*> res;
- for(unsigned int i = 0 ; i < m_Block.size(); i++){
- if(m_Block[i]->GetMainToken() == Token){
+ for (unsigned int i = 0; i < m_Block.size(); i++) {
+ if (m_Block[i]->GetMainToken() == Token) {
res.push_back(m_Block[i]);
}
}
return res;
-
}
////////////////////////////////////////////////////////////////////////////////
-std::vector<NPL::InputBlock*> NPL::InputParser::GetAllBlocksWithTokenAndValue(std::string Token,std::string Value){
+std::vector<NPL::InputBlock*> NPL::InputParser::GetAllBlocksWithTokenAndValue(std::string Token, std::string Value) {
std::vector<NPL::InputBlock*> res;
- for(unsigned int i = 0 ; i < m_Block.size(); i++){
- if(m_Block[i]->GetMainToken() == Token){
- if(m_Block[i]->GetMainValue() == Value)
+ for (unsigned int i = 0; i < m_Block.size(); i++) {
+ if (m_Block[i]->GetMainToken() == Token) {
+ if (m_Block[i]->GetMainValue() == Value)
res.push_back(m_Block[i]);
}
}
@@ -349,20 +351,20 @@ std::vector<NPL::InputBlock*> NPL::InputParser::GetAllBlocksWithTokenAndValue(st
}
////////////////////////////////////////////////////////////////////////////////
-std::vector<std::string> NPL::InputParser::GetAllBlocksToken(){
+std::vector<std::string> NPL::InputParser::GetAllBlocksToken() {
std::vector<std::string> token;
- for(unsigned int i = 0 ; i < m_Block.size() ; i++){
+ for (unsigned int i = 0; i < m_Block.size(); i++) {
token.push_back(m_Block[i]->GetMainToken());
}
return token;
}
////////////////////////////////////////////////////////////////////////////////
-std::vector<std::string> NPL::InputParser::GetAllBlocksValues(std::string token){
+std::vector<std::string> NPL::InputParser::GetAllBlocksValues(std::string token) {
std::vector<std::string> value;
std::vector<NPL::InputBlock*> blocks = GetAllBlocksWithToken(token);
unsigned int size = blocks.size();
- for(unsigned int i = 0 ; i < size ; i++){
+ for (unsigned int i = 0; i < size; i++) {
value.push_back(blocks[i]->GetMainValue());
}
@@ -370,74 +372,73 @@ std::vector<std::string> NPL::InputParser::GetAllBlocksValues(std::string token)
}
////////////////////////////////////////////////////////////////////////////////
-void NPL::InputParser::TreatAliases(){
+void NPL::InputParser::TreatAliases() {
// Call the alias block
std::vector<NPL::InputBlock*> alias = GetAllBlocksWithToken("Alias");
- // List of token:
+ // List of token:
- // - Action
+ // - Action
// -> Split : create new block for each value
// -> Inplace : Replace the value in existing alias
// - Value -> The list of value to be used
- std::vector<std::string> token = {"Action","Value"};
- for(unsigned int i = 0 ; i < alias.size() ; i++){
- if(!alias[i]->HasTokenList(token)){
+ std::vector<std::string> token = {"Action", "Value"};
+ for (unsigned int i = 0; i < alias.size(); i++) {
+ if (!alias[i]->HasTokenList(token)) {
NPL::SendErrorAndExit("NPL::InputParser", "Alias block syntax incorrect");
}
-
- int verbose = 1; //NPOptionManager::getInstance()->GetVerboseLevel();
- if(verbose)
+ int verbose = 1; // NPOptionManager::getInstance()->GetVerboseLevel();
+
+ if (verbose)
std::cout << "Using Alias : @" << alias[i]->GetMainValue() << std::endl;
-
- std::string name="@";
- name += alias[i]->GetMainValue();
+
+ std::string name = "@";
+ name += alias[i]->GetMainValue();
std::string action = alias[i]->GetString("Action");
- std::vector<std::string> value = alias[i]->GetVectorString("Value");
- if(action=="Replace" && value.size()!=1)
- NPL::SendErrorAndExit("NPL::InputParser", "Inplace alias can only take one value");
+ std::vector<std::string> value = alias[i]->GetVectorString("Value");
+ if (action == "Replace" && value.size() != 1)
+ NPL::SendErrorAndExit("NPL::InputParser", "Inplace alias can only take one value");
// Scan all blocks for aliases
- for(unsigned int b = 0 ; b < m_Block.size() ; b++){
+ for (unsigned int b = 0; b < m_Block.size(); b++) {
unsigned int size = m_Block[b]->GetSize();
- size_t pos;
+ size_t pos;
// In place case loop over each value and replace them
- if(action=="Replace"){
- for(unsigned int v = 0 ; v < size ; v++){
- while((pos=m_Block[b]->GetValue(v).find(name))!=std::string::npos){
+ if (action == "Replace") {
+ for (unsigned int v = 0; v < size; v++) {
+ while ((pos = m_Block[b]->GetValue(v).find(name)) != std::string::npos) {
std::string val = m_Block[b]->GetValue(v);
- val.replace(pos,name.length(),value[0]);
- m_Block[b]->SetValue(v,val);
+ val.replace(pos, name.length(), value[0]);
+ m_Block[b]->SetValue(v, val);
}
}
}
- else if (action=="Copy"){
+ else if (action == "Copy") {
bool check = false;
// first pass identify if the block use an alias
- for(unsigned int v = 0 ; v < size ; v++){
- if(m_Block[b]->GetValue(v).find(name)!=std::string::npos)
- check = true;
+ for (unsigned int v = 0; v < size; v++) {
+ if (m_Block[b]->GetValue(v).find(name) != std::string::npos)
+ check = true;
}
- if(check){
+ if (check) {
NPL::InputBlock* originalBlock = m_Block[b]->Copy();
- for(unsigned int a = 0 ; a < value.size() ; a++){
+ for (unsigned int a = 0; a < value.size(); a++) {
NPL::InputBlock* newBlock = originalBlock->Copy();
- for(unsigned int v = 0 ; v < size ; v++){
- while((pos=newBlock->GetValue(v).find(name))!=std::string::npos){
+ for (unsigned int v = 0; v < size; v++) {
+ while ((pos = newBlock->GetValue(v).find(name)) != std::string::npos) {
std::string val = newBlock->GetValue(v);
- val.replace(pos,name.length(),value[a]);
- newBlock->SetValue(v,val);
+ val.replace(pos, name.length(), value[a]);
+ newBlock->SetValue(v, val);
}
-
}
- if(a==0){
+ if (a == 0) {
m_Block[b] = newBlock;
}
- else{
+ else {
std::vector<NPL::InputBlock*>::iterator it = m_Block.begin();
- m_Block.insert(it+b+a,newBlock);
+ m_Block.insert(it + b + a, newBlock);
}
}
}
@@ -446,16 +447,16 @@ void NPL::InputParser::TreatAliases(){
}
}
////////////////////////////////////////////////////////////////////////////////
-void NPL::InputParser::ReadFile(std::string filename,bool ExitOnError){
+void NPL::InputParser::ReadFile(std::string filename, bool ExitOnError) {
Clear();
std::ifstream file(filename.c_str());
- if(!file.is_open()){
+ if (!file.is_open()) {
std::ostringstream message;
message << "file " << filename << " not found " << std::endl;
- if(ExitOnError)
+ if (ExitOnError)
NPL::SendErrorAndExit("NPL::InputParser", message.str());
- else{
+ else {
NPL::SendWarning("NPL::InputParser", message.str());
return;
}
@@ -463,28 +464,28 @@ void NPL::InputParser::ReadFile(std::string filename,bool ExitOnError){
std::string line;
NPL::InputBlock* block = 0;
- while(!file.eof()){
- getline(file,line);
- if(IsNotComment(line) && GetLevel(line)==0) {
- if(block)
+ while (!file.eof()) {
+ getline(file, line);
+ if (IsNotComment(line) && GetLevel(line) == 0) {
+ if (block)
m_Block.push_back(block);
block = new NPL::InputBlock(line);
- if(!file.eof())
- getline(file,line);
+ if (!file.eof())
+ getline(file, line);
}
- if(block && IsNotComment(line)){
+ if (block && IsNotComment(line)) {
block->AddLine(line);
}
}
// Add the last block
- if(block)
+ if (block)
m_Block.push_back(block);
TreatAliases();
}
////////////////////////////////////////////////////////////////////////////////
-void NPL::InputParser::Clear(){
- for(unsigned int i = 0 ; m_Block.size() ; i++)
+void NPL::InputParser::Clear() {
+ for (unsigned int i = 0; m_Block.size(); i++)
delete m_Block[i];
m_Block.clear();
@@ -492,479 +493,479 @@ void NPL::InputParser::Clear(){
}
////////////////////////////////////////////////////////////////////////////////
-double NPL::ApplyUnit(double value, std::string unit){
- if(unit=="void") // apply no unit
+double NPL::ApplyUnit(double value, std::string unit) {
+ if (unit == "void") // apply no unit
return value;
- else if(unit=="g/cm3"){
- return value*NPUNITS::g/NPUNITS::cm3;
+ else if (unit == "g/cm3") {
+ return value * NPUNITS::g / NPUNITS::cm3;
}
- else if(unit=="kg/cm3"){
- return value*NPUNITS::kg/NPUNITS::cm3;
+ else if (unit == "kg/cm3") {
+ return value * NPUNITS::kg / NPUNITS::cm3;
}
-
- else if(unit=="millimeter"){
- return value*NPUNITS::millimeter;
+
+ else if (unit == "millimeter") {
+ return value * NPUNITS::millimeter;
}
- else if(unit=="millimeter2"){
- return value*NPUNITS::millimeter2;
+ else if (unit == "millimeter2") {
+ return value * NPUNITS::millimeter2;
}
- else if(unit=="millimeter3"){
- return value*NPUNITS::millimeter3;
+ else if (unit == "millimeter3") {
+ return value * NPUNITS::millimeter3;
}
- else if(unit=="centimeter"){
- return value*NPUNITS::centimeter;
+ else if (unit == "centimeter") {
+ return value * NPUNITS::centimeter;
}
- else if(unit=="centimeter2"){
- return value*NPUNITS::centimeter2;
+ else if (unit == "centimeter2") {
+ return value * NPUNITS::centimeter2;
}
- else if(unit=="centimeter3"){
- return value*NPUNITS::centimeter3;
+ else if (unit == "centimeter3") {
+ return value * NPUNITS::centimeter3;
}
- else if(unit=="meter"){
- return value*NPUNITS::meter;
+ else if (unit == "meter") {
+ return value * NPUNITS::meter;
}
- else if(unit=="meter2"){
- return value*NPUNITS::meter2;
+ else if (unit == "meter2") {
+ return value * NPUNITS::meter2;
}
- else if(unit=="meter3"){
- return value*NPUNITS::meter3;
+ else if (unit == "meter3") {
+ return value * NPUNITS::meter3;
}
- else if(unit=="kilometer"){
- return value*NPUNITS::kilometer;
+ else if (unit == "kilometer") {
+ return value * NPUNITS::kilometer;
}
- else if(unit=="kilometer2"){
- return value*NPUNITS::kilometer2;
+ else if (unit == "kilometer2") {
+ return value * NPUNITS::kilometer2;
}
- else if(unit=="kilometer3"){
- return value*NPUNITS::kilometer3;
+ else if (unit == "kilometer3") {
+ return value * NPUNITS::kilometer3;
}
- else if(unit=="parsec"){
- return value*NPUNITS::parsec;
+ else if (unit == "parsec") {
+ return value * NPUNITS::parsec;
}
- else if(unit=="micrometer"){
- return value*NPUNITS::micrometer;
+ else if (unit == "micrometer") {
+ return value * NPUNITS::micrometer;
}
- else if(unit=="nanometer"){
- return value*NPUNITS::nanometer;
+ else if (unit == "nanometer") {
+ return value * NPUNITS::nanometer;
}
- else if(unit=="angstrom"){
- return value*NPUNITS::angstrom;
+ else if (unit == "angstrom") {
+ return value * NPUNITS::angstrom;
}
- else if(unit=="fermi"){
- return value*NPUNITS::fermi;
+ else if (unit == "fermi") {
+ return value * NPUNITS::fermi;
}
- else if(unit=="barn"){
- return value*NPUNITS::barn;
+ else if (unit == "barn") {
+ return value * NPUNITS::barn;
}
- else if(unit=="millibarn"){
- return value*NPUNITS::millibarn;
+ else if (unit == "millibarn") {
+ return value * NPUNITS::millibarn;
}
- else if(unit=="microbarn"){
- return value*NPUNITS::microbarn;
+ else if (unit == "microbarn") {
+ return value * NPUNITS::microbarn;
}
- else if(unit=="nanobarn"){
- return value*NPUNITS::nanobarn;
+ else if (unit == "nanobarn") {
+ return value * NPUNITS::nanobarn;
}
- else if(unit=="picobarn"){
- return value*NPUNITS::picobarn;
+ else if (unit == "picobarn") {
+ return value * NPUNITS::picobarn;
}
- else if(unit=="mm"){
- return value*NPUNITS::mm;
+ else if (unit == "mm") {
+ return value * NPUNITS::mm;
}
- else if(unit=="um"){
- return value*NPUNITS::um;
+ else if (unit == "um") {
+ return value * NPUNITS::um;
}
- else if(unit=="nm"){
- return value*NPUNITS::nm;
+ else if (unit == "nm") {
+ return value * NPUNITS::nm;
}
- else if(unit=="mm2"){
- return value*NPUNITS::mm2;
+ else if (unit == "mm2") {
+ return value * NPUNITS::mm2;
}
- else if(unit=="mm3"){
- return value*NPUNITS::mm3;
+ else if (unit == "mm3") {
+ return value * NPUNITS::mm3;
}
- else if(unit=="cm"){
- return value*NPUNITS::cm;
+ else if (unit == "cm") {
+ return value * NPUNITS::cm;
}
- else if(unit=="cm2"){
- return value*NPUNITS::cm2;
+ else if (unit == "cm2") {
+ return value * NPUNITS::cm2;
}
- else if(unit=="cm3"){
- return value*NPUNITS::cm3;
+ else if (unit == "cm3") {
+ return value * NPUNITS::cm3;
}
- else if(unit=="m"){
- return value*NPUNITS::m;
+ else if (unit == "m") {
+ return value * NPUNITS::m;
}
- else if(unit=="m2"){
- return value*NPUNITS::m2;
+ else if (unit == "m2") {
+ return value * NPUNITS::m2;
}
- else if(unit=="m3"){
- return value*NPUNITS::m3;
+ else if (unit == "m3") {
+ return value * NPUNITS::m3;
}
- else if(unit=="km"){
- return value*NPUNITS::km;
+ else if (unit == "km") {
+ return value * NPUNITS::km;
}
- else if(unit=="km2"){
- return value*NPUNITS::km2;
+ else if (unit == "km2") {
+ return value * NPUNITS::km2;
}
- else if(unit=="km3"){
- return value*NPUNITS::km3;
+ else if (unit == "km3") {
+ return value * NPUNITS::km3;
}
- else if(unit=="pc"){
- return value*NPUNITS::pc;
+ else if (unit == "pc") {
+ return value * NPUNITS::pc;
}
- else if(unit=="radian"){
- return value*NPUNITS::radian;
+ else if (unit == "radian") {
+ return value * NPUNITS::radian;
}
- else if(unit=="milliradian"){
- return value*NPUNITS::milliradian;
+ else if (unit == "milliradian") {
+ return value * NPUNITS::milliradian;
}
- else if(unit=="degree"){
- return value*NPUNITS::degree;
+ else if (unit == "degree") {
+ return value * NPUNITS::degree;
}
- else if(unit=="steradian"){
- return value*NPUNITS::steradian;
+ else if (unit == "steradian") {
+ return value * NPUNITS::steradian;
}
- else if(unit=="rad"){
- return value*NPUNITS::rad;
+ else if (unit == "rad") {
+ return value * NPUNITS::rad;
}
- else if(unit=="mrad"){
- return value*NPUNITS::mrad;
+ else if (unit == "mrad") {
+ return value * NPUNITS::mrad;
}
- else if(unit=="sr"){
- return value*NPUNITS::sr;
+ else if (unit == "sr") {
+ return value * NPUNITS::sr;
}
- else if(unit=="deg"){
- return value*NPUNITS::deg;
+ else if (unit == "deg") {
+ return value * NPUNITS::deg;
}
- else if(unit=="nanosecond"){
- return value*NPUNITS::nanosecond;
+ else if (unit == "nanosecond") {
+ return value * NPUNITS::nanosecond;
}
- else if(unit=="second"){
- return value*NPUNITS::second;
+ else if (unit == "second") {
+ return value * NPUNITS::second;
}
- else if(unit=="millisecond"){
- return value*NPUNITS::millisecond;
+ else if (unit == "millisecond") {
+ return value * NPUNITS::millisecond;
}
- else if(unit=="microsecond"){
- return value*NPUNITS::microsecond;
+ else if (unit == "microsecond") {
+ return value * NPUNITS::microsecond;
}
- else if(unit=="picosecond"){
- return value*NPUNITS::picosecond;
+ else if (unit == "picosecond") {
+ return value * NPUNITS::picosecond;
}
- else if(unit=="hertz"){
- return value*NPUNITS::hertz;
+ else if (unit == "hertz") {
+ return value * NPUNITS::hertz;
}
- else if(unit=="kilohertz"){
- return value*NPUNITS::kilohertz;
+ else if (unit == "kilohertz") {
+ return value * NPUNITS::kilohertz;
}
- else if(unit=="megahertz"){
- return value*NPUNITS::megahertz;
+ else if (unit == "megahertz") {
+ return value * NPUNITS::megahertz;
}
- else if(unit=="ns"){
- return value*NPUNITS::ns;
+ else if (unit == "ns") {
+ return value * NPUNITS::ns;
}
- else if(unit=="us"){
- return value*NPUNITS::us;
+ else if (unit == "us") {
+ return value * NPUNITS::us;
}
- else if(unit=="ms"){
- return value*NPUNITS::ms;
+ else if (unit == "ms") {
+ return value * NPUNITS::ms;
}
- else if(unit=="eplus"){
- return value*NPUNITS::eplus;
+ else if (unit == "eplus") {
+ return value * NPUNITS::eplus;
}
- else if(unit=="e_SI"){
- return value*NPUNITS::e_SI;
+ else if (unit == "e_SI") {
+ return value * NPUNITS::e_SI;
}
- else if(unit=="coulomb"){
- return value*NPUNITS::coulomb;
+ else if (unit == "coulomb") {
+ return value * NPUNITS::coulomb;
}
- else if(unit=="megaelectron"){
- return value*NPUNITS::megaelectronvolt;
+ else if (unit == "megaelectron") {
+ return value * NPUNITS::megaelectronvolt;
}
- else if(unit=="electronvolt"){
- return value*NPUNITS::electronvolt;
+ else if (unit == "electronvolt") {
+ return value * NPUNITS::electronvolt;
}
- else if(unit=="kiloelectron"){
- return value*NPUNITS::kiloelectronvolt;
+ else if (unit == "kiloelectron") {
+ return value * NPUNITS::kiloelectronvolt;
}
- else if(unit=="gigaelectron"){
- return value*NPUNITS::gigaelectronvolt;
+ else if (unit == "gigaelectron") {
+ return value * NPUNITS::gigaelectronvolt;
}
- else if(unit=="teraelectron"){
- return value*NPUNITS::teraelectronvolt;
+ else if (unit == "teraelectron") {
+ return value * NPUNITS::teraelectronvolt;
}
- else if(unit=="petaelectron"){
- return value*NPUNITS::petaelectronvolt;
+ else if (unit == "petaelectron") {
+ return value * NPUNITS::petaelectronvolt;
}
- else if(unit=="joule"){
- return value*NPUNITS::joule;
+ else if (unit == "joule") {
+ return value * NPUNITS::joule;
}
- else if(unit=="MeV"){
- return value*NPUNITS::MeV;
+ else if (unit == "MeV") {
+ return value * NPUNITS::MeV;
}
- else if(unit=="eV"){
- return value*NPUNITS::eV;
+ else if (unit == "eV") {
+ return value * NPUNITS::eV;
}
- else if(unit=="keV"){
- return value*NPUNITS::keV;
+ else if (unit == "keV") {
+ return value * NPUNITS::keV;
}
- else if(unit=="GeV"){
- return value*NPUNITS::GeV;
+ else if (unit == "GeV") {
+ return value * NPUNITS::GeV;
}
- else if(unit=="TeV"){
- return value*NPUNITS::TeV;
+ else if (unit == "TeV") {
+ return value * NPUNITS::TeV;
}
- else if(unit=="PeV"){
- return value*NPUNITS::PeV;
+ else if (unit == "PeV") {
+ return value * NPUNITS::PeV;
}
- else if(unit=="kilogram"){
- return value*NPUNITS::kilogram;
+ else if (unit == "kilogram") {
+ return value * NPUNITS::kilogram;
}
- else if(unit=="gram"){
- return value*NPUNITS::gram;
+ else if (unit == "gram") {
+ return value * NPUNITS::gram;
}
- else if(unit=="milligram"){
- return value*NPUNITS::milligram;
+ else if (unit == "milligram") {
+ return value * NPUNITS::milligram;
}
- else if(unit=="kg"){
- return value*NPUNITS::kg;
+ else if (unit == "kg") {
+ return value * NPUNITS::kg;
}
- else if(unit=="g"){
- return value*NPUNITS::g;
+ else if (unit == "g") {
+ return value * NPUNITS::g;
}
- else if(unit=="mg"){
- return value*NPUNITS::mg;
+ else if (unit == "mg") {
+ return value * NPUNITS::mg;
}
- else if(unit=="watt"){
- return value*NPUNITS::watt;
+ else if (unit == "watt") {
+ return value * NPUNITS::watt;
}
- else if(unit=="newton"){
- return value*NPUNITS::newton;
+ else if (unit == "newton") {
+ return value * NPUNITS::newton;
}
- else if(unit=="hep_pascal"){
- return value*NPUNITS::hep_pascal;
+ else if (unit == "hep_pascal") {
+ return value * NPUNITS::hep_pascal;
}
- else if(unit=="bar"){
- return value*NPUNITS::bar;
+ else if (unit == "bar") {
+ return value * NPUNITS::bar;
}
- else if(unit=="atmosphere"){
- return value*NPUNITS::atmosphere;
+ else if (unit == "atmosphere") {
+ return value * NPUNITS::atmosphere;
}
- else if(unit=="ampere"){
- return value*NPUNITS::ampere;
+ else if (unit == "ampere") {
+ return value * NPUNITS::ampere;
}
- else if(unit=="milliampere"){
- return value*NPUNITS::milliampere;
+ else if (unit == "milliampere") {
+ return value * NPUNITS::milliampere;
}
- else if(unit=="microampere"){
- return value*NPUNITS::microampere;
+ else if (unit == "microampere") {
+ return value * NPUNITS::microampere;
}
- else if(unit=="nanoampere"){
- return value*NPUNITS::nanoampere;
+ else if (unit == "nanoampere") {
+ return value * NPUNITS::nanoampere;
}
- else if(unit=="megavolt"){
- return value*NPUNITS::megavolt;
+ else if (unit == "megavolt") {
+ return value * NPUNITS::megavolt;
}
- else if(unit=="kilovolt"){
- return value*NPUNITS::kilovolt;
+ else if (unit == "kilovolt") {
+ return value * NPUNITS::kilovolt;
}
- else if(unit=="volt"){
- return value*NPUNITS::volt;
+ else if (unit == "volt") {
+ return value * NPUNITS::volt;
}
- else if(unit=="ohm"){
- return value*NPUNITS::ohm;
+ else if (unit == "ohm") {
+ return value * NPUNITS::ohm;
}
- else if(unit=="farad"){
- return value*NPUNITS::farad;
+ else if (unit == "farad") {
+ return value * NPUNITS::farad;
}
- else if(unit=="millifarad"){
- return value*NPUNITS::millifarad;
+ else if (unit == "millifarad") {
+ return value * NPUNITS::millifarad;
}
- else if(unit=="microfarad"){
- return value*NPUNITS::microfarad;
+ else if (unit == "microfarad") {
+ return value * NPUNITS::microfarad;
}
- else if(unit=="nanofarad"){
- return value*NPUNITS::nanofarad;
+ else if (unit == "nanofarad") {
+ return value * NPUNITS::nanofarad;
}
- else if(unit=="picofarad"){
- return value*NPUNITS::picofarad;
+ else if (unit == "picofarad") {
+ return value * NPUNITS::picofarad;
}
- else if(unit=="weber"){
- return value*NPUNITS::weber;
+ else if (unit == "weber") {
+ return value * NPUNITS::weber;
}
- else if(unit=="tesla" || unit=="T"){
- return value*NPUNITS::tesla;
+ else if (unit == "tesla" || unit == "T") {
+ return value * NPUNITS::tesla;
}
- else if(unit=="gauss"){
- return value*NPUNITS::gauss;
+ else if (unit == "gauss") {
+ return value * NPUNITS::gauss;
}
- else if(unit=="kilogauss"){
- return value*NPUNITS::kilogauss;
+ else if (unit == "kilogauss") {
+ return value * NPUNITS::kilogauss;
}
- else if(unit=="henry"){
- return value*NPUNITS::henry;
+ else if (unit == "henry") {
+ return value * NPUNITS::henry;
}
- else if(unit=="kelvin"){
- return value*NPUNITS::kelvin;
+ else if (unit == "kelvin") {
+ return value * NPUNITS::kelvin;
}
- else if(unit=="mole"){
- return value*NPUNITS::mole;
+ else if (unit == "mole") {
+ return value * NPUNITS::mole;
}
- else if(unit=="becquerel"){
- return value*NPUNITS::becquerel;
+ else if (unit == "becquerel") {
+ return value * NPUNITS::becquerel;
}
- else if(unit=="curie"){
- return value*NPUNITS::curie;
+ else if (unit == "curie") {
+ return value * NPUNITS::curie;
}
- else if(unit=="gray"){
- return value*NPUNITS::gray;
+ else if (unit == "gray") {
+ return value * NPUNITS::gray;
}
- else if(unit=="kilogray"){
- return value*NPUNITS::kilogray;
+ else if (unit == "kilogray") {
+ return value * NPUNITS::kilogray;
}
- else if(unit=="milligray"){
- return value*NPUNITS::milligray;
+ else if (unit == "milligray") {
+ return value * NPUNITS::milligray;
}
- else if(unit=="microgray"){
- return value*NPUNITS::microgray;
+ else if (unit == "microgray") {
+ return value * NPUNITS::microgray;
}
- else if(unit=="candela"){
- return value*NPUNITS::candela;
+ else if (unit == "candela") {
+ return value * NPUNITS::candela;
}
- else if(unit=="lumen"){
- return value*NPUNITS::lumen;
+ else if (unit == "lumen") {
+ return value * NPUNITS::lumen;
}
- else if(unit=="lux"){
- return value*NPUNITS::lux;
+ else if (unit == "lux") {
+ return value * NPUNITS::lux;
}
- else if(unit=="perCent"){
- return value*NPUNITS::perCent;
+ else if (unit == "perCent") {
+ return value * NPUNITS::perCent;
}
- else if(unit=="perThousand"){
- return value*NPUNITS::perThousand;
+ else if (unit == "perThousand") {
+ return value * NPUNITS::perThousand;
}
- else if(unit=="perMillion"){
- return value*NPUNITS::perMillion;
+ else if (unit == "perMillion") {
+ return value * NPUNITS::perMillion;
}
- else{
+ else {
std::cout << "WARNING: Unknown unit " << unit << std::endl;
return value;
}
diff --git a/NPLib/Core/NPInputParser.h b/NPLib/Core/NPInputParser.h
index 2c58e7d482bb318eb13d3e9fc7d5345c0f5ea96e..788dd3ec763a624b90065ba95db48d959bb223e7 100644
--- a/NPLib/Core/NPInputParser.h
+++ b/NPLib/Core/NPInputParser.h
@@ -22,17 +22,15 @@
* *
*****************************************************************************/
-
// STL
-#include<string>
-#include<vector>
-#include<map>
+#include <map>
+#include <string>
+#include <vector>
// ROOT
-#include"TVector3.h"
-
+#include "TVector3.h"
-namespace NPL{
+namespace NPL {
static std::string token_separator = "=";
std::string StripSpaces(std::string line);
@@ -40,85 +38,84 @@ namespace NPL{
double ApplyUnit(double value, std::string unit);
unsigned int GetLevel(std::string line);
- class InputBlock{
- public:
- InputBlock(){};
- InputBlock(std::string line);
- ~InputBlock(){};
- NPL::InputBlock* Copy();
-
- private:
- unsigned int m_Level;
- std::string m_MainToken;
- std::string m_MainValue;
- std::vector<std::string> m_Token;
- std::vector<std::string> m_Value;
- std::vector<std::string> m_Lines;
-
- public:
- void AddLine(std::string line);
- std::string ExtractToken(std::string line,std::string separator="");
- std::string ExtractValue(std::string line,std::string separator="");
-
- public:
- std::string GetToken(unsigned int i){return m_Token[i];};
- std::string GetValue(unsigned int i){return m_Value[i];};
- std::string GetValue(std::string Token);
- void SetValue(unsigned int i, std::string val){m_Value[i]=val;};
-
-
- public:
- bool HasTokenList(std::vector<std::string> TokenList);
- bool HasToken(std::string Token);
-
- public:
- std::string GetMainToken(){return m_MainToken;};
- std::string GetMainValue(){return m_MainValue;};
-
- unsigned int GetSize(){return m_Token.size();};
- double GetDouble(std::string Token,std::string default_unit);
- int GetInt(std::string Token);
- std::string GetString(std::string Token);
- TVector3 GetTVector3(std::string Token,std::string default_unit);
- std::vector<double> GetVectorDouble(std::string Token,std::string default_unit);
- std::vector<int> GetVectorInt(std::string Token);
- std::vector<std::string> GetVectorString(std::string Token);
- std::vector<NPL::InputBlock*> GetSubBlock(std::string Token);
- std::vector<std::string> GetLines(){return m_Lines;};
-
- public:
- void Dump();
+ class InputBlock {
+ public:
+ InputBlock(){};
+ InputBlock(std::string line);
+ ~InputBlock(){};
+ NPL::InputBlock* Copy();
+
+ private:
+ unsigned int m_Level;
+ std::string m_MainToken;
+ std::string m_MainValue;
+ std::vector<std::string> m_Token;
+ std::vector<std::string> m_Value;
+ std::vector<std::string> m_Lines;
+
+ public:
+ void AddLine(std::string line);
+ std::string ExtractToken(std::string line, std::string separator = "");
+ std::string ExtractValue(std::string line, std::string separator = "");
+
+ public:
+ std::string GetToken(unsigned int i) { return m_Token[i]; };
+ std::string GetValue(unsigned int i) { return m_Value[i]; };
+ std::string GetValue(std::string Token);
+ void SetValue(unsigned int i, std::string val) { m_Value[i] = val; };
+
+ public:
+ bool HasTokenList(std::vector<std::string> TokenList);
+ std::vector<std::string> GetMissingToken(std::vector<std::string> TokenList);
+ bool HasToken(std::string Token);
+
+ public:
+ std::string GetMainToken() { return m_MainToken; };
+ std::string GetMainValue() { return m_MainValue; };
+
+ unsigned int GetSize() { return m_Token.size(); };
+ double GetDouble(std::string Token, std::string default_unit);
+ int GetInt(std::string Token);
+ std::string GetString(std::string Token);
+ TVector3 GetTVector3(std::string Token, std::string default_unit);
+ std::vector<double> GetVectorDouble(std::string Token, std::string default_unit);
+ std::vector<int> GetVectorInt(std::string Token);
+ std::vector<std::string> GetVectorString(std::string Token);
+ std::vector<NPL::InputBlock*> GetSubBlock(std::string Token);
+ std::vector<std::string> GetLines() { return m_Lines; };
+
+ public:
+ void Dump();
};
////////////////////////////////////////////////////////////////////////////////
- class InputParser{
- public:
- InputParser(){};
- InputParser(std::string filename,bool ExitOnError=true) {ReadFile(filename,ExitOnError);}
- ~InputParser(){};
-
- private:
- std::vector<InputBlock*> m_Block;
- std::map<std::string, std::vector<std::string> > m_Aliases;
-
- private:
- int m_verbose;
-
- public:
- void ReadFile(std::string filename,bool ExitOnError=true);
- void TreatAliases();
- void TreatOneAlias(){};
- void Dump();
- void Print() {Dump();}
- void Clear();
- std::vector<InputBlock*> GetAllBlocksWithToken(std::string Token);
- std::vector<InputBlock*> GetAllBlocksWithTokenAndValue(std::string Token,std::string Value);
- std::vector<std::string> GetAllBlocksValues(std::string);
- std::vector<std::string> GetAllBlocksToken();
-
-
- private:
- bool IsNotComment(std::string line);
+ class InputParser {
+ public:
+ InputParser(){};
+ InputParser(std::string filename, bool ExitOnError = true) { ReadFile(filename, ExitOnError); }
+ ~InputParser(){};
+
+ private:
+ std::vector<InputBlock*> m_Block;
+ std::map<std::string, std::vector<std::string>> m_Aliases;
+
+ private:
+ int m_verbose;
+
+ public:
+ void ReadFile(std::string filename, bool ExitOnError = true);
+ void TreatAliases();
+ void TreatOneAlias(){};
+ void Dump();
+ void Print() { Dump(); }
+ void Clear();
+ std::vector<InputBlock*> GetAllBlocksWithToken(std::string Token);
+ std::vector<InputBlock*> GetAllBlocksWithTokenAndValue(std::string Token, std::string Value);
+ std::vector<std::string> GetAllBlocksValues(std::string);
+ std::vector<std::string> GetAllBlocksToken();
+
+ private:
+ bool IsNotComment(std::string line);
};
-}
+} // namespace NPL
#endif
diff --git a/NPLib/Detectors/NebulaPlus/TNebulaPlusData.h b/NPLib/Detectors/NebulaPlus/TNebulaPlusData.h
index f11345e2a2531945ec79af0f040bb643c26fe7e3..4ec8fef6c467904c8426ca601eb0289bd22f4945 100644
--- a/NPLib/Detectors/NebulaPlus/TNebulaPlusData.h
+++ b/NPLib/Detectors/NebulaPlus/TNebulaPlusData.h
@@ -89,30 +89,30 @@ class TNebulaPlusData : public TObject {
////////////////////// GETTERS ////////////////////////
// MULT //
- inline unsigned int GetUpMult() const
+ inline unsigned int GetMultUp() const
{return fNebulaPlus_u_ID.size();};
- inline unsigned int GetDownMult() const
+ inline unsigned int GetMultDown() const
{return fNebulaPlus_d_ID.size();};
// Value //
// Up
- inline UShort_t GetUpID(unsigned int& i) const
+ inline unsigned short GetIDUp(const int& i) const
{return fNebulaPlus_u_ID[i];};
- inline double GetUpQ(unsigned int& i) const
+ inline double GetQUp(const int& i) const
{return fNebulaPlus_u_Q[i];};
- inline double GetUpQ4(unsigned int& i) const
+ inline double GetQ4Up(const int& i) const
{return fNebulaPlus_u_Q4[i];};
- inline double GetUpT(unsigned int& i) const
+ inline double GetTUp(const int& i) const
{return fNebulaPlus_u_T[i];};
// Down
- inline UShort_t GetDownID(unsigned int& i) const
+ inline unsigned short GetIDDown(const int& i) const
{return fNebulaPlus_d_ID[i];};
- inline double GetDownQ(unsigned int& i) const
+ inline double GetQDown(const int& i) const
{return fNebulaPlus_d_Q[i];};
- inline double GetDownQ4(unsigned int& i) const
+ inline double GetQ4Down(const int& i) const
{return fNebulaPlus_d_Q4[i];};
- inline double GetDownT(unsigned int& i) const
+ inline double GetTDown(const int& i) const
{return fNebulaPlus_d_T[i];};
//////////////////////////////////////////////////////////////
diff --git a/NPLib/Detectors/NebulaPlus/TNebulaPlusPhysics.cxx b/NPLib/Detectors/NebulaPlus/TNebulaPlusPhysics.cxx
index 4c7dcaacf44635d4104c34260caf8c8e8a9164df..2cc21b541427acf6d5a3ad51dc1be33055f901a6 100644
--- a/NPLib/Detectors/NebulaPlus/TNebulaPlusPhysics.cxx
+++ b/NPLib/Detectors/NebulaPlus/TNebulaPlusPhysics.cxx
@@ -6,7 +6,7 @@
*****************************************************************************/
/*****************************************************************************
- * Original Author: Adrien Matta contact address: matta@lpccaen.in2p3.fr *
+ * Original Author: Freddy Flavigny contact: flavigny@lpccaen.in2p3.fr *
* *
* Creation Date : December 2019 *
* Last update : *
@@ -21,6 +21,7 @@
*****************************************************************************/
#include "TNebulaPlusPhysics.h"
+using namespace NEBULAPLUS_LOCAL;
// STL
#include <sstream>
@@ -47,50 +48,56 @@ TNebulaPlusPhysics::TNebulaPlusPhysics()
: m_EventData(new TNebulaPlusData),
m_EventPhysics(this),
m_Spectra(0),
- m_Q_RAW_Threshold(0), // adc channels
- m_Q_Threshold(7), // normal bars in MeV
- m_V_Threshold(1), // veto bars in MeV
+ m_Q_RAW_Threshold(15000), // adc channels
+ m_Q_Threshold(0), // normal bars in MeV
+ m_V_Threshold(0), // veto bar in MeV
+ m_TotalNbrModules(0),
+ m_BarWidth(12), // bar width in cm
+ m_BarLength(180), // bar length in cm
+ m_TdiffRange(12), // +- range in (Td-Tu) in ns
m_NumberOfBars(0) {
}
-///////////////////////////////////////////////////////////////////////////
-/// A usefull method to bundle all operation to add a detector
-void TNebulaPlusPhysics::ReadXML(NPL::XmlParser xml){
- std::vector<NPL::XML::block*> b = xml.GetAllBlocksWithName("NEBULA");
-
- for(unsigned int i = 0 ; i < b.size() ; i++){
- m_NumberOfBars++;
- unsigned int id = b[i]->AsInt("ID");
-
- // position
- PositionX[id] = b[i]->AsDouble("PosX");
- PositionY[id] = b[i]->AsDouble("PosY");
- PositionZ[id] = b[i]->AsDouble("PosZ");
- // linear cal
- aQu[id] = b[i]->AsDouble("QUCal");
- bQu[id] = b[i]->AsDouble("QUPed");
- aQd[id] = b[i]->AsDouble("QDCal");
- bQd[id] = b[i]->AsDouble("QDPed");
- aTu[id] = b[i]->AsDouble("TUCal");
- bTu[id] = b[i]->AsDouble("TUOff");
- aTd[id] = b[i]->AsDouble("TDCal");
- bTd[id] = b[i]->AsDouble("TDOff");
-
- // T average offset
- avgT0[id] = b[i]->AsDouble("TAveOff");
-
- // slew correction T= tcal +slwT/sqrt(Qcal)
- slwTu[id] = b[i]->AsDouble("TUSlw");
- slwTd[id] = b[i]->AsDouble("TDSlw");
-
- // DT position cal
- DTa[id] = b[i]->AsDouble("DTCal");//!
- DTb[id] = b[i]->AsDouble("DTOff");//!
-
-
- }
- cout << " -> " << m_NumberOfBars << " bars found" << endl;;
-}
+/////////////////////////////////////////////
+//// Innherited from VDetector Class ////
+/////////////////////////////////////////////
+void TNebulaPlusPhysics::ReadConfiguration(NPL::InputParser parser) {
+
+ vector<NPL::InputBlock*> blocks = parser.GetAllBlocksWithToken("NEBULAPLUS");
+ if (NPOptionManager::getInstance()->GetVerboseLevel())
+ cout << "//// " << blocks.size() << " Nebula layers found " << endl;
+
+ unsigned int det=0;
+ // Cartesian Case
+ vector<string> info
+ = {"POS","NumberOfModules", "Veto", "Frame"};
+ string Type;
+
+ for (unsigned int i = 0; i < blocks.size(); i++) {
+
+ if (blocks[i]->HasTokenList(info)) {
+ if (NPOptionManager::getInstance()->GetVerboseLevel())
+
+ cout << endl << "//// Nebula Layer " << Type << " " << i + 1 << endl;
+ int NbrOfModulesInLayer = blocks[i]->GetInt("NumberOfModules");
+ //det = i+1;
+ //m_DetectorNumberIndex[detectorNbr]=det;
+ TVector3 Pos = blocks[i]->GetTVector3("Pos", "cm");
+ AddLayer(Pos, NbrOfModulesInLayer);
+ }
+
+ else {
+ cout << "ERROR: Missing token for NebulaPlus, check your input "
+ "file"
+ << endl;
+ exit(1);
+ }
+
+ }
+
+ //InitializeStandardParameter();
+ //ReadAnalysisConfig();
+}
///////////////////////////////////////////////////////////////////////////
void TNebulaPlusPhysics::BuildSimplePhysicalEvent() {
@@ -101,103 +108,101 @@ void TNebulaPlusPhysics::BuildSimplePhysicalEvent() {
///////////////////////////////////////////////////////////////////////////
void TNebulaPlusPhysics::BuildPhysicalEvent() {
+
// apply thresholds and calibration
-/*
+ //std::cout << "----------------" << std::endl;
+ //std::cout << "in BuildPhysical" << std::endl;
+
// instantiate CalibrationManager
static CalibrationManager* Cal = CalibrationManager::getInstance();
+ //Cal->Dump();
+ //double offset = Cal->GetValue("NebulaPlus/Tdiff_Offset_58",0);
+ //double offset = Cal->GetValue("NebulaPlus/U3_ENERGY",1);
+
+
static double rawQup,calQup,rawQdown,calQdown,rawTup,calTup,rawTdown,calTdown,calQ,calT,Y;
static unsigned int ID;
// All vector size
- static unsigned int QUsize, QDsize, TUsize, TDsize ;
- QUsize = m_EventData->GetChargeUpMult();
- QDsize = m_EventData->GetChargeDownMult();
- TUsize = m_EventData->GetTimeUpMult();
- TDsize = m_EventData->GetTimeDownMult();
+ static unsigned int Usize, Dsize ;
+ Usize = m_EventData->GetMultUp();
+ Dsize = m_EventData->GetMultDown();
static double threshold;
- // loop on Qup
- for (unsigned int qup = 0; qup < QUsize ; qup++) {
+ bool matchUD;
+ int unmatched=0;
+
+ // loop on up
+ //std::cout << "size up" << Usize<< std::endl;
+ //std::cout << "size down" << Dsize<< std::endl;
- rawQup = m_EventData->GetChargeUp(qup);
- rawTup=-1;
+ for (unsigned int up = 0; up < Usize ; up++) {
+
+ rawQup = m_EventData->GetQUp(up);
+ rawTup= m_EventData->GetTUp(up);
rawQdown=-1;
rawTdown=-1;
+ matchUD = false;
if (rawQup > m_Q_RAW_Threshold) {
- ID = m_EventData->GetChargeUpID(qup);
- if(ID<121)
- threshold=m_Q_Threshold;
- else
- threshold=m_V_Threshold;
-
- // look for associated Charge down
- for(unsigned int qdown = 0 ; qdown < QDsize ; qdown++){
- if(m_EventData->GetChargeDownID(qdown)==ID){
- rawQdown=m_EventData->GetChargeDown(qdown);
- if(rawQdown > m_Q_RAW_Threshold){
- // Look for the associate time
- for(unsigned int tdown = 0 ; tdown < TDsize; tdown++){
- if(m_EventData->GetTimeDownID(qdown)==ID) {
- rawTdown=m_EventData->GetTimeDown(qdown);
- break;
- }
- }// TDown
- }//if raw threshold down
- break;
+ ID = m_EventData->GetIDUp(up);
+
+ // look for associated down
+ for(unsigned int down = 0 ; down < Dsize ; down++){
+ if(m_EventData->GetIDDown(down)==ID){
+
+ //std::cout << "-------" << std::endl;
+ //std::cout << "same ID:\t" << ID<< std::endl;
+ if( m_EventData->GetQDown(down) > m_Q_RAW_Threshold){
+ rawQdown = m_EventData->GetQDown(down);
+ rawTdown = m_EventData->GetTDown(down);
+ calQup = fCalQUp(m_EventData,up);
+ calQdown = fCalQDown(m_EventData,down);
+ matchUD = true;
+ break;
+ }//if raw threshold down
} //if match ID
+ }// down
- }// Qdwown
+ // Got a Down-Up match, do the math
+ if(matchUD){
- if(rawTdown>0){ // Tdown is found, means Qdown as well
- // look for Tup
- for(unsigned int tup = 0 ; tup < TUsize ; tup++){
- if(m_EventData->GetTimeUpID(tup)==ID){
- rawTup = m_EventData->GetTimeUp(tup);
- break;
- }
- }
- }
- // Got everything, do the math
- if(rawTup>0){
// cal Q Up and Down
- calQup=aQu[ID]*(rawQup-bQu[ID]);
- calQdown=aQd[ID]*(rawQdown-bQd[ID]);
+ //calQup = aQu[ID] * (rawQup-bQu[ID]);
+ //calQdown= aQd[ID] * (rawQdown-bQd[ID]);
// average value of Up and Down
calQ=sqrt(calQup*calQdown);
// cal T Up
- calTup=aTu[ID]*rawTup+bTu[ID];
- // slew correction
- calTup -= slwTu[ID]/sqrt(rawQup-bQu[ID]);
+ //calTup=aTu[ID]*rawTup+bTu[ID];
+ calTup=rawTup;
// cal T Down
- calTdown=aTd[ID]*rawTdown+bTd[ID];
- // slew correction
- calTdown -= slwTd[ID]/sqrt(rawQdown-bQd[ID]);
+ //calTdown=aTd[ID]*rawTdown+bTd[ID];
+ calTdown=rawTdown;
-
if(calQ>threshold){
- calT= (calTdown+calTup)*0.5+avgT0[ID]+Cal->GetPedestal("NEBULA_T_ID"+NPL::itoa(ID));
- Y=(calTdown-calTup)*DTa[ID]+DTb[ID]+Cal->GetPedestal("NEBULA_Y_ID"+NPL::itoa(ID));
+ calT= (calTdown+calTup)*0.5;
+ Y=(calTdown-calTup) - Cal->GetValue("NebulaPlus/Tdiff_Offset_"+NPL::itoa(ID),0);
DetectorNumber.push_back(ID);
Charge.push_back(calQ);
TOF.push_back(calT);
- PosY.push_back(Y+PositionY[ID]);
- PosX.push_back(PositionX[ID]);
- PosZ.push_back(PositionZ[ID]);
-
+ PosX.push_back(m_BarPositionX[ID-1]);
+ PosY.push_back(Y/m_TdiffRange*m_BarLength);
+ PosZ.push_back(m_BarPositionZ[ID-1]);
+/*
if(ID<121)
IsVeto.push_back(0);
else
IsVeto.push_back(1);
-
+*/
}
+ } else {
+ unmatched++;/*std::cout << "unmatched=" <<unmatched<< std::endl;*/
}
-
}// if raw threshold up
} // Qup
-*/
+
}
///////////////////////////////////////////////////////////////////////////
@@ -205,8 +210,17 @@ void TNebulaPlusPhysics::PreTreat() {
}
+///////////////////////////////////////////////////////////////////////////
+void TNebulaPlusPhysics::AddLayer(TVector3 Pos, int n_modules) {
+ for(int i=0; i<n_modules; i++){
+ m_BarPositionX.push_back(Pos.X() + i * m_BarWidth);
+ m_BarPositionY.push_back(Pos.Y());
+ m_BarPositionZ.push_back(Pos.Z());
+ m_TotalNbrModules++;
+ }
+}
///////////////////////////////////////////////////////////////////////////
void TNebulaPlusPhysics::ReadAnalysisConfig() {
}
@@ -227,8 +241,9 @@ void TNebulaPlusPhysics::Clear() {
///////////////////////////////////////////////////////////////////////////
+/*
void TNebulaPlusPhysics::ReadConfiguration(NPL::InputParser parser) {
- vector<NPL::InputBlock*> blocks = parser.GetAllBlocksWithToken("NEBULA");
+ vector<NPL::InputBlock*> blocks = parser.GetAllBlocksWithToken("NEBULAPLUS");
if(NPOptionManager::getInstance()->GetVerboseLevel())
cout << "//// " << blocks.size() << " detector(s) found " << endl;
@@ -251,7 +266,7 @@ void TNebulaPlusPhysics::ReadConfiguration(NPL::InputParser parser) {
}
}
}
-
+*/
///////////////////////////////////////////////////////////////////////////
void TNebulaPlusPhysics::InitSpectra() {
m_Spectra = new TNebulaPlusSpectra(m_NumberOfBars);
@@ -296,21 +311,18 @@ void TNebulaPlusPhysics::WriteSpectra() {
m_Spectra->WriteSpectra();
}
-
-
///////////////////////////////////////////////////////////////////////////
void TNebulaPlusPhysics::AddParameterToCalibrationManager() {
CalibrationManager* Cal = CalibrationManager::getInstance();
- vector<double> standardO={0};
- for (int i = 0; i < m_NumberOfBars; ++i) {
- Cal->AddParameter("NEBULA_T_ID"+ NPL::itoa(i+1),standardO);
- Cal->AddParameter("NEBULA_Y_ID"+ NPL::itoa(i+1),standardO);
+ vector<double> standard={8192, 6};
+ for (int i = 0; i < m_TotalNbrModules; ++i) {
+ Cal->AddParameter("NebulaPlus","U"+ NPL::itoa(i+1)+"_ENERGY","NebulaPlus_U"+ NPL::itoa(i+1)+"_ENERGY",standard);
+ Cal->AddParameter("NebulaPlus","D"+ NPL::itoa(i+1)+"_ENERGY","NebulaPlus_D"+ NPL::itoa(i+1)+"_ENERGY",standard);
+ Cal->AddParameter("NebulaPlus","Tdiff_Offset_"+ NPL::itoa(i+1),"NebulaPlus_Tdiff_Offset_"+ NPL::itoa(i+1),standard);
}
}
-
-
///////////////////////////////////////////////////////////////////////////
void TNebulaPlusPhysics::InitializeRootInputRaw() {
TChain* inputChain = RootInput::getInstance()->GetChain();
@@ -318,8 +330,6 @@ void TNebulaPlusPhysics::InitializeRootInputRaw() {
inputChain->SetBranchAddress("NebulaPlus", &m_EventData );
}
-
-
///////////////////////////////////////////////////////////////////////////
void TNebulaPlusPhysics::InitializeRootInputPhysics() {
TChain* inputChain = RootInput::getInstance()->GetChain();
@@ -327,14 +337,32 @@ void TNebulaPlusPhysics::InitializeRootInputPhysics() {
}
-
///////////////////////////////////////////////////////////////////////////
void TNebulaPlusPhysics::InitializeRootOutput() {
TTree* outputTree = RootOutput::getInstance()->GetTree("NebulaPlus");
outputTree->Branch("NebulaPlus", "TNebulaPlusPhysics", &m_EventPhysics);
}
+////////////////////////////////////////////////////////////////////////////////
+namespace NEBULAPLUS_LOCAL{
+
+double fCalQUp(const TNebulaPlusData* m_EventData, const int& i){
+ static string name;
+ name = "NebulaPlus/U";
+ name += NPL::itoa(m_EventData->GetIDUp(i));
+ name += "_ENERGY";
+ return CalibrationManager::getInstance()->ApplyCalibration(name, m_EventData->GetQUp(i), 1);
+}
+
+double fCalQDown(const TNebulaPlusData* m_EventData, const int& i){
+ static string name;
+ name = "NebulaPlus/D";
+ name += NPL::itoa(m_EventData->GetIDDown(i));
+ name += "_ENERGY";
+ return CalibrationManager::getInstance()->ApplyCalibration(name, m_EventData->GetQDown(i), 1);
+}
+}
////////////////////////////////////////////////////////////////////////////////
// Construct Method to be pass to the DetectorFactory //
diff --git a/NPLib/Detectors/NebulaPlus/TNebulaPlusPhysics.h b/NPLib/Detectors/NebulaPlus/TNebulaPlusPhysics.h
index 32b1a9547f03740eca22cbcd4898283be3e732d4..4d4d6c55ce10e848e8021f48cb83faaf14334a7d 100644
--- a/NPLib/Detectors/NebulaPlus/TNebulaPlusPhysics.h
+++ b/NPLib/Detectors/NebulaPlus/TNebulaPlusPhysics.h
@@ -76,7 +76,7 @@ class TNebulaPlusPhysics : public TObject, public NPL::VDetector {
return TVector3(PosX[i],PosY[i],PosZ[i]);
}
- // Return true if one veto fired
+ // Return true if one veto fired (not used for now)
bool HasVeto(){
unsigned int size = IsVeto.size();
for(unsigned int i = 0 ; i < size ; i++){
@@ -105,8 +105,8 @@ class TNebulaPlusPhysics : public TObject, public NPL::VDetector {
};
public:
- /// A usefull method to bundle all operation to add a detector
- void ReadXML(NPL::XmlParser);
+ /// A useful method to bundle all operation to add a detector
+ void ReadCalibration(NPL::InputParser);
//////////////////////////////////////////////////////////////
// methods inherited from the VDetector ABC class
@@ -193,46 +193,33 @@ class TNebulaPlusPhysics : public TObject, public NPL::VDetector {
double m_Q_Threshold; //!
double m_V_Threshold; //!
+ private: //FF addition
+ int m_TotalNbrModules; //!
+ double m_BarWidth; //!
+ double m_BarLength; //!
+ double m_TdiffRange; //!
+ vector<double> m_BarPositionX; //!
+ vector<double> m_BarPositionY; //!
+ vector<double> m_BarPositionZ; //!
+ void AddLayer(TVector3 Pos, int n_modules);
+
+ public:
+ double GetBarPositionX(const int N) {return m_BarPositionX[N - 1];}
+ double GetBarPositionY(const int N) {return m_BarPositionY[N - 1];}
+ double GetBarPositionZ(const int N) {return m_BarPositionZ[N - 1];}
+
public:
void SetQThreshold(double t) {m_Q_Threshold=t;};
void SetVThreshold(double t) {m_V_Threshold=t;};
// number of detectors
private:
int m_NumberOfBars; //!
-
+/*
private: // offset and inversion
std::map<unsigned int, TVector3> m_offset;//!
std::map<unsigned int, bool> m_invertX;//!
std::map<unsigned int, bool> m_invertY;//!
-
- private: // xml calibration
- // position
- std::map<unsigned int , double > PositionX;//!
- std::map<unsigned int , double > PositionY;//!
- std::map<unsigned int , double > PositionZ;//!
-
- // linear cal
- std::map<unsigned int , double > aQu;//!
- std::map<unsigned int , double > bQu;//!
- std::map<unsigned int , double > aQd;//!
- std::map<unsigned int , double > bQd;//!
- std::map<unsigned int , double > aTu;//!
- std::map<unsigned int , double > bTu;//!
- std::map<unsigned int , double > aTd;//!
- std::map<unsigned int , double > bTd;//!
-
- // T average offset
- std::map<unsigned int , double > avgT0;//!
-
- // slew correction T= tcal +slwT/sqrt(Qcal)
- std::map<unsigned int , double > slwTu;//!
- std::map<unsigned int , double > slwTd;//!
-
- // DT position cal
- std::map<unsigned int , double > DTa;//!
- std::map<unsigned int , double > DTb;//!
-
-
+*/
// spectra class
private:
TNebulaPlusSpectra* m_Spectra; // !
@@ -247,4 +234,12 @@ class TNebulaPlusPhysics : public TObject, public NPL::VDetector {
ClassDef(TNebulaPlusPhysics,1) // NebulaPlusPhysics structure
};
+
+namespace NEBULAPLUS_LOCAL{
+double fCalQUp(const TNebulaPlusData* Data, const int& i);
+double fCalQDown(const TNebulaPlusData* Data, const int& i);
+
+
+
+}
#endif
diff --git a/NPSimulation/Detectors/Minos/Minos.cc b/NPSimulation/Detectors/Minos/Minos.cc
index 88a18ed5cfae669704d05299c7f060d9558ada3a..ea4ac5d1c96bd5973945fde1e96236420a995aa3 100644
--- a/NPSimulation/Detectors/Minos/Minos.cc
+++ b/NPSimulation/Detectors/Minos/Minos.cc
@@ -323,6 +323,12 @@ void Minos::ReadConfiguration(NPL::InputParser parser) {
}
else {
cout << "ERROR: check your input file formatting " << endl;
+ cout << " missing token : ";
+ auto missing = blocks[i]->GetMissingToken(token);
+ for (unsigned int i = 0; i < missing.size(); i++) {
+ std::cout << missing[i] << " ";
+ }
+ std::cout << endl;
exit(1);
}
}
@@ -333,7 +339,7 @@ void Minos::ReadConfiguration(NPL::InputParser parser) {
// Called After DetecorConstruction::AddDetector Method
void Minos::ConstructDetector(G4LogicalVolume* world) {
for (unsigned short i = 0; i < m_POS.size(); i++) {
- bool TPCOnly = m_TPCOnly[i];
+ TPCOnly = m_TPCOnly[i];
/* TargetMaterial = MaterialManager::getInstance()->GetMaterialFromLibrary("Vacuum"); */
TargetMaterial = MaterialManager::getInstance()->GetMaterialFromLibrary("LH2");
diff --git a/Projects/NebulaPlus/.gitignore b/Projects/NebulaPlus/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..0d62deb8e3ce2f9649e855aad5762a3c2ea6b88d
--- /dev/null
+++ b/Projects/NebulaPlus/.gitignore
@@ -0,0 +1,2 @@
+./root
+./raw_root
diff --git a/Projects/NebulaPlus/Analysis.cxx b/Projects/NebulaPlus/Analysis.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..83eb160239b7abe57137db7b858c010d24590548
--- /dev/null
+++ b/Projects/NebulaPlus/Analysis.cxx
@@ -0,0 +1,83 @@
+/*****************************************************************************
+ * 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: XAUTHORX contact address: XMAILX *
+ * *
+ * Creation Date : XMONTHX XYEARX *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class describe Nebula analysis project *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ *****************************************************************************/
+
+#include<iostream>
+using namespace std;
+#include"Analysis.h"
+#include"TGraph.h"
+#include"TCanvas.h"
+#include"TPad.h"
+#include"NPAnalysisFactory.h"
+#include"NPDetectorManager.h"
+////////////////////////////////////////////////////////////////////////////////
+Analysis::Analysis(){
+}
+////////////////////////////////////////////////////////////////////////////////
+Analysis::~Analysis(){
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Analysis::Init(){
+ NebulaPlus= (TNebulaPlusPhysics*) m_DetectorManager->GetDetector("NEBULAPLUS");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Analysis::TreatEvent(){
+/*
+ TGraph* g = new TGraph();
+ for(int i=0; i<NebulaPlus->DetectorNumber.size(); i++){
+ //if(i==0)std::cout << "------------------" << std::endl;
+ //std::cout << NebulaPlus->GetPos(i).X() << std::endl;
+ g->SetPoint(i,NebulaPlus->GetPos(i).X(),NebulaPlus->GetPos(i).Y())
+ }
+*/
+// TGraph* g = new TGraph(NebulaPlus->DetectorNumber.size(),&(NebulaPlus->PosX[0]),&(NebulaPlus->PosY[0]));
+ // g->Fit("pol1");
+
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+void Analysis::End(){
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Construct Method to be pass to the DetectorFactory //
+////////////////////////////////////////////////////////////////////////////////
+NPL::VAnalysis* Analysis::Construct(){
+ return (NPL::VAnalysis*) new Analysis();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Registering the construct method to the factory //
+////////////////////////////////////////////////////////////////////////////////
+extern "C"{
+class proxy{
+ public:
+ proxy(){
+ NPL::AnalysisFactory::getInstance()->SetConstructor(Analysis::Construct);
+ }
+};
+
+proxy p;
+}
+
diff --git a/Projects/NebulaPlus/Analysis.h b/Projects/NebulaPlus/Analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca51067ee431814ada236f4e582e205f2cf0456f
--- /dev/null
+++ b/Projects/NebulaPlus/Analysis.h
@@ -0,0 +1,42 @@
+#ifndef Analysis_h
+#define Analysis_h
+/*****************************************************************************
+ * 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: XAUTHORX contact address: XMAILX *
+ * *
+ * Creation Date : XMONTHX XYEARX *
+ * Last update : *
+ *---------------------------------------------------------------------------*
+ * Decription: *
+ * This class describe Nebula analysis project *
+ * *
+ *---------------------------------------------------------------------------*
+ * Comment: *
+ * *
+ *****************************************************************************/
+
+#include"NPVAnalysis.h"
+#include"TNebulaPlusPhysics.h"
+class Analysis: public NPL::VAnalysis{
+ public:
+ Analysis();
+ ~Analysis();
+
+ public:
+ void Init();
+ void TreatEvent();
+ void End();
+
+ static NPL::VAnalysis* Construct();
+
+ private:
+ TNebulaPlusPhysics* NebulaPlus;
+
+};
+#endif
diff --git a/Projects/NebulaPlus/CMakeLists.txt b/Projects/NebulaPlus/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..22c74affdfc45019bdda2594f8439c52d4ab97ec
--- /dev/null
+++ b/Projects/NebulaPlus/CMakeLists.txt
@@ -0,0 +1,5 @@
+cmake_minimum_required (VERSION 2.8)
+# Setting the policy to match Cmake version
+cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+# include the default NPAnalysis cmake file
+include("../../NPLib/ressources/CMake/NPAnalysis.cmake")
diff --git a/Projects/NebulaPlus/Makefile b/Projects/NebulaPlus/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..7e183603a93b2331c3b57ac00feb94dede691b8e
--- /dev/null
+++ b/Projects/NebulaPlus/Makefile
@@ -0,0 +1,178 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Default target executed when no arguments are given to make.
+default_target: all
+
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/expand/Experiments/Test_SAMURAI/nptool/Projects/NebulaPlus
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/expand/Experiments/Test_SAMURAI/nptool/Projects/NebulaPlus
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+ @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
+ /usr/bin/cmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target edit_cache
+edit_cache:
+ @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "No interactive CMake dialog available..."
+ /usr/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+
+.PHONY : edit_cache/fast
+
+# The main all target
+all: cmake_check_build_system
+ $(CMAKE_COMMAND) -E cmake_progress_start /home/expand/Experiments/Test_SAMURAI/nptool/Projects/NebulaPlus/CMakeFiles /home/expand/Experiments/Test_SAMURAI/nptool/Projects/NebulaPlus/CMakeFiles/progress.marks
+ $(MAKE) -f CMakeFiles/Makefile2 all
+ $(CMAKE_COMMAND) -E cmake_progress_start /home/expand/Experiments/Test_SAMURAI/nptool/Projects/NebulaPlus/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+ $(MAKE) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+ $(MAKE) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+ $(MAKE) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+ $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+#=============================================================================
+# Target rules for targets named NPAnalysis
+
+# Build rule for target.
+NPAnalysis: cmake_check_build_system
+ $(MAKE) -f CMakeFiles/Makefile2 NPAnalysis
+.PHONY : NPAnalysis
+
+# fast build rule for target.
+NPAnalysis/fast:
+ $(MAKE) -f CMakeFiles/NPAnalysis.dir/build.make CMakeFiles/NPAnalysis.dir/build
+.PHONY : NPAnalysis/fast
+
+Analysis.o: Analysis.cxx.o
+
+.PHONY : Analysis.o
+
+# target to build an object file
+Analysis.cxx.o:
+ $(MAKE) -f CMakeFiles/NPAnalysis.dir/build.make CMakeFiles/NPAnalysis.dir/Analysis.cxx.o
+.PHONY : Analysis.cxx.o
+
+Analysis.i: Analysis.cxx.i
+
+.PHONY : Analysis.i
+
+# target to preprocess a source file
+Analysis.cxx.i:
+ $(MAKE) -f CMakeFiles/NPAnalysis.dir/build.make CMakeFiles/NPAnalysis.dir/Analysis.cxx.i
+.PHONY : Analysis.cxx.i
+
+Analysis.s: Analysis.cxx.s
+
+.PHONY : Analysis.s
+
+# target to generate assembly for a file
+Analysis.cxx.s:
+ $(MAKE) -f CMakeFiles/NPAnalysis.dir/build.make CMakeFiles/NPAnalysis.dir/Analysis.cxx.s
+.PHONY : Analysis.cxx.s
+
+# Help Target
+help:
+ @echo "The following are some of the valid targets for this Makefile:"
+ @echo "... all (the default if no target is provided)"
+ @echo "... clean"
+ @echo "... depend"
+ @echo "... rebuild_cache"
+ @echo "... edit_cache"
+ @echo "... NPAnalysis"
+ @echo "... Analysis.o"
+ @echo "... Analysis.i"
+ @echo "... Analysis.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+ $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/Projects/NebulaPlus/NebulaPlus.detector b/Projects/NebulaPlus/NebulaPlus.detector
new file mode 100644
index 0000000000000000000000000000000000000000..029a0a119feaa716a710b482d9e4e2f0c29650e5
--- /dev/null
+++ b/Projects/NebulaPlus/NebulaPlus.detector
@@ -0,0 +1,68 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Target
+ THICKNESS= 0.49 cm
+ RADIUS= 28 mm
+ MATERIAL= Vacuum
+ ANGLE= 0 deg
+ X= 3.5 cm
+ Y= 0 mm
+ Z= 0 mm
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+NEBULAPLUS
+ POS= 0 0 0 cm
+ NumberOfModules= 22
+ Veto= 0
+ Frame= 0
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+NEBULAPLUS
+ POS= 0 0 13 cm
+ NumberOfModules= 22
+ Veto= 0
+ Frame= 0
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+NEBULAPLUS
+ POS= 0 0 84.5 cm
+ NumberOfModules= 23
+ Veto= 0
+ Frame= 0
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+NEBULAPLUS
+ POS= 0 0 97.5 cm
+ NumberOfModules= 25
+ Veto= 0
+ Frame= 0
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%Samurai
+% POS= 0 0 0 mm
+% ANGLE= 30 deg
+% %
+% METHOD= 1
+% % 0=RungeKutta, 1=EliaOmar
+% FIELDMAP=3T.table.bin
+% %fieldmap/3T.table.bin
+% % fieldmap path
+% STEPS_PER_METER= 1000
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%SAMURAIFDC1
+% %XML= db/SAMURAIFDC0_20200109.xml
+% %Offset= -0.00666226 0.102191 -3370.01 mm
+% Offset= -0.00666226 0.102191 -4370.01 mm
+% %InvertX= 1
+% %InvertY= 0
+% %InvertD= 1
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%SAMURAIFDC2
+% %XML= db/SAMURAIFDC2.xml
+% Offset= 1000 200 5000 mm
+% OffAngle= 59.930 deg
+% %-252.416 -0.228477 4122.57 mm
+% %InvertX= 0
+% %InvertY= 1
+% %InvertD= 1
+
+
diff --git a/Projects/NebulaPlus/PhysicsListOption.txt b/Projects/NebulaPlus/PhysicsListOption.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2a32a3b1722a1ec55d040d6e46faf8b513c453a0
--- /dev/null
+++ b/Projects/NebulaPlus/PhysicsListOption.txt
@@ -0,0 +1,11 @@
+EmPhysicsList Option4
+DefaultCutOff 1
+IonBinaryCascadePhysics 0
+NPIonInelasticPhysics 0
+EmExtraPhysics 0
+HadronElasticPhysics 0
+StoppingPhysics 0
+OpticalPhysics 0
+HadronPhysicsINCLXX 0
+HadronPhysicsQGSP_BIC_HP 1
+Decay 0
diff --git a/Projects/NebulaPlus/RunToTreat.txt b/Projects/NebulaPlus/RunToTreat.txt
new file mode 100755
index 0000000000000000000000000000000000000000..18635cc9c11300c5e957e63dfe44159135575752
--- /dev/null
+++ b/Projects/NebulaPlus/RunToTreat.txt
@@ -0,0 +1,4 @@
+TTreeName
+ RawTree
+RootFileName
+ ./raw_root/run_38_0001.root
diff --git a/Projects/NebulaPlus/SimpleNeutrons.reaction b/Projects/NebulaPlus/SimpleNeutrons.reaction
new file mode 100755
index 0000000000000000000000000000000000000000..6f5aea35fb4485aedc285ab8ba581ecc955b4c9a
--- /dev/null
+++ b/Projects/NebulaPlus/SimpleNeutrons.reaction
@@ -0,0 +1,14 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Beam
+ Particle= n
+ Energy= 196 MeV
+ SigmaEnergy= 0.5 MeV
+ SigmaThetaX= 0.01 deg
+ SigmaPhiY= 0.01 deg
+ SigmaX= 0.5 mm
+ SigmaY= 0.5 mm
+ MeanThetaX= 0 deg
+ MeanPhiY= 0 deg
+ MeanX= 3.5 cm
+ MeanY= 0 mm
+ ZEmission= -1000 mm
diff --git a/Projects/NebulaPlus/calibration.txt b/Projects/NebulaPlus/calibration.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3e5bd1d0f20981ae8758f2eba2ebc7bd84007ff1
--- /dev/null
+++ b/Projects/NebulaPlus/calibration.txt
@@ -0,0 +1,4 @@
+CalibrationFilePath
+./calibration/NebulaPlus_Up_Energy.cal
+./calibration/NebulaPlus_Down_Energy.cal
+./calibration/NebulaPlus_Tdiff_Offset.cal
diff --git a/Projects/NebulaPlus/calibration/NebulaPlus_Down_Energy.cal b/Projects/NebulaPlus/calibration/NebulaPlus_Down_Energy.cal
new file mode 100644
index 0000000000000000000000000000000000000000..dc432020a0080222dc32d6ab314e3ffc1e42830d
--- /dev/null
+++ b/Projects/NebulaPlus/calibration/NebulaPlus_Down_Energy.cal
@@ -0,0 +1,91 @@
+NebulaPlus_D1_ENERGY 0 1
+NebulaPlus_D2_ENERGY 0 1
+NebulaPlus_D3_ENERGY 0 1
+NebulaPlus_D4_ENERGY 0 1
+NebulaPlus_D5_ENERGY 0 1
+NebulaPlus_D6_ENERGY 0 1
+NebulaPlus_D7_ENERGY 0 1
+NebulaPlus_D8_ENERGY 0 1
+NebulaPlus_D9_ENERGY 0 1
+NebulaPlus_D10_ENERGY 0 1
+NebulaPlus_D11_ENERGY 0 1
+NebulaPlus_D12_ENERGY 0 1
+NebulaPlus_D13_ENERGY 0 1
+NebulaPlus_D14_ENERGY 0 1
+NebulaPlus_D15_ENERGY 0 1
+NebulaPlus_D16_ENERGY 0 1
+NebulaPlus_D17_ENERGY 0 1
+NebulaPlus_D18_ENERGY 0 1
+NebulaPlus_D19_ENERGY 0 1
+NebulaPlus_D20_ENERGY 0 1
+NebulaPlus_D21_ENERGY 0 1
+NebulaPlus_D22_ENERGY 0 1
+NebulaPlus_D23_ENERGY 0 1
+NebulaPlus_D24_ENERGY 0 1
+NebulaPlus_D25_ENERGY 0 1
+NebulaPlus_D26_ENERGY 0 1
+NebulaPlus_D27_ENERGY 0 1
+NebulaPlus_D28_ENERGY 0 1
+NebulaPlus_D29_ENERGY 0 1
+NebulaPlus_D30_ENERGY 0 1
+NebulaPlus_D31_ENERGY 0 1
+NebulaPlus_D32_ENERGY 0 1
+NebulaPlus_D33_ENERGY 0 1
+NebulaPlus_D34_ENERGY 0 1
+NebulaPlus_D35_ENERGY 0 1
+NebulaPlus_D36_ENERGY 0 1
+NebulaPlus_D37_ENERGY 0 1
+NebulaPlus_D38_ENERGY 0 1
+NebulaPlus_D39_ENERGY 0 1
+NebulaPlus_D40_ENERGY 0 1
+NebulaPlus_D41_ENERGY 0 1
+NebulaPlus_D42_ENERGY 0 1
+NebulaPlus_D43_ENERGY 0 1
+NebulaPlus_D44_ENERGY 0 1
+NebulaPlus_D45_ENERGY 0 1
+NebulaPlus_D46_ENERGY 0 1
+NebulaPlus_D47_ENERGY 0 1
+NebulaPlus_D48_ENERGY 0 1
+NebulaPlus_D49_ENERGY 0 1
+NebulaPlus_D50_ENERGY 0 1
+NebulaPlus_D51_ENERGY 0 1
+NebulaPlus_D52_ENERGY 0 1
+NebulaPlus_D53_ENERGY 0 1
+NebulaPlus_D54_ENERGY 0 1
+NebulaPlus_D55_ENERGY 0 1
+NebulaPlus_D56_ENERGY 0 1
+NebulaPlus_D57_ENERGY 0 1
+NebulaPlus_D58_ENERGY 0 1
+NebulaPlus_D59_ENERGY 0 1
+NebulaPlus_D60_ENERGY 0 1
+NebulaPlus_D61_ENERGY 0 1
+NebulaPlus_D62_ENERGY 0 1
+NebulaPlus_D63_ENERGY 0 1
+NebulaPlus_D64_ENERGY 0 1
+NebulaPlus_D65_ENERGY 0 1
+NebulaPlus_D66_ENERGY 0 1
+NebulaPlus_D67_ENERGY 0 1
+NebulaPlus_D68_ENERGY 0 1
+NebulaPlus_D69_ENERGY 0 1
+NebulaPlus_D70_ENERGY 0 1
+NebulaPlus_D71_ENERGY 0 1
+NebulaPlus_D72_ENERGY 0 1
+NebulaPlus_D73_ENERGY 0 1
+NebulaPlus_D74_ENERGY 0 1
+NebulaPlus_D75_ENERGY 0 1
+NebulaPlus_D76_ENERGY 0 1
+NebulaPlus_D77_ENERGY 0 1
+NebulaPlus_D78_ENERGY 0 1
+NebulaPlus_D79_ENERGY 0 1
+NebulaPlus_D80_ENERGY 0 1
+NebulaPlus_D81_ENERGY 0 1
+NebulaPlus_D82_ENERGY 0 1
+NebulaPlus_D83_ENERGY 0 1
+NebulaPlus_D84_ENERGY 0 1
+NebulaPlus_D85_ENERGY 0 1
+NebulaPlus_D86_ENERGY 0 1
+NebulaPlus_D87_ENERGY 0 1
+NebulaPlus_D88_ENERGY 0 1
+NebulaPlus_D89_ENERGY 0 1
+NebulaPlus_D90_ENERGY 0 1
+
diff --git a/Projects/NebulaPlus/calibration/NebulaPlus_Energy.cal b/Projects/NebulaPlus/calibration/NebulaPlus_Energy.cal
new file mode 100644
index 0000000000000000000000000000000000000000..77372aef6c2ff5914e4c177473c50884ecc713ad
--- /dev/null
+++ b/Projects/NebulaPlus/calibration/NebulaPlus_Energy.cal
@@ -0,0 +1,91 @@
+NebulaPlus_U1_ENERGY 0 1
+NebulaPlus_U2_ENERGY 0 1
+NebulaPlus_U3_ENERGY 0 1
+NebulaPlus_U4_ENERGY 0 1
+NebulaPlus_U5_ENERGY 0 1
+NebulaPlus_U6_ENERGY 0 1
+NebulaPlus_U7_ENERGY 0 1
+NebulaPlus_U8_ENERGY 0 1
+NebulaPlus_U9_ENERGY 0 1
+NebulaPlus_U10_ENERGY 0 1
+NebulaPlus_U11_ENERGY 0 1
+NebulaPlus_U12_ENERGY 0 1
+NebulaPlus_U13_ENERGY 0 1
+NebulaPlus_U14_ENERGY 0 1
+NebulaPlus_U15_ENERGY 0 1
+NebulaPlus_U16_ENERGY 0 1
+NebulaPlus_U17_ENERGY 0 1
+NebulaPlus_U18_ENERGY 0 1
+NebulaPlus_U19_ENERGY 0 1
+NebulaPlus_U20_ENERGY 0 1
+NebulaPlus_U21_ENERGY 0 1
+NebulaPlus_U22_ENERGY 0 1
+NebulaPlus_U23_ENERGY 0 1
+NebulaPlus_U24_ENERGY 0 1
+NebulaPlus_U25_ENERGY 0 1
+NebulaPlus_U26_ENERGY 0 1
+NebulaPlus_U27_ENERGY 0 1
+NebulaPlus_U28_ENERGY 0 1
+NebulaPlus_U29_ENERGY 0 1
+NebulaPlus_U30_ENERGY 0 1
+NebulaPlus_U31_ENERGY 0 1
+NebulaPlus_U32_ENERGY 0 1
+NebulaPlus_U33_ENERGY 0 1
+NebulaPlus_U34_ENERGY 0 1
+NebulaPlus_U35_ENERGY 0 1
+NebulaPlus_U36_ENERGY 0 1
+NebulaPlus_U37_ENERGY 0 1
+NebulaPlus_U38_ENERGY 0 1
+NebulaPlus_U39_ENERGY 0 1
+NebulaPlus_U40_ENERGY 0 1
+NebulaPlus_U41_ENERGY 0 1
+NebulaPlus_U42_ENERGY 0 1
+NebulaPlus_U43_ENERGY 0 1
+NebulaPlus_U44_ENERGY 0 1
+NebulaPlus_U45_ENERGY 0 1
+NebulaPlus_U46_ENERGY 0 1
+NebulaPlus_U47_ENERGY 0 1
+NebulaPlus_U48_ENERGY 0 1
+NebulaPlus_U49_ENERGY 0 1
+NebulaPlus_U50_ENERGY 0 1
+NebulaPlus_U51_ENERGY 0 1
+NebulaPlus_U52_ENERGY 0 1
+NebulaPlus_U53_ENERGY 0 1
+NebulaPlus_U54_ENERGY 0 1
+NebulaPlus_U55_ENERGY 0 1
+NebulaPlus_U56_ENERGY 0 1
+NebulaPlus_U57_ENERGY 0 1
+NebulaPlus_U58_ENERGY 0 1
+NebulaPlus_U59_ENERGY 0 1
+NebulaPlus_U60_ENERGY 0 1
+NebulaPlus_U61_ENERGY 0 1
+NebulaPlus_U62_ENERGY 0 1
+NebulaPlus_U63_ENERGY 0 1
+NebulaPlus_U64_ENERGY 0 1
+NebulaPlus_U65_ENERGY 0 1
+NebulaPlus_U66_ENERGY 0 1
+NebulaPlus_U67_ENERGY 0 1
+NebulaPlus_U68_ENERGY 0 1
+NebulaPlus_U69_ENERGY 0 1
+NebulaPlus_U70_ENERGY 0 1
+NebulaPlus_U71_ENERGY 0 1
+NebulaPlus_U72_ENERGY 0 1
+NebulaPlus_U73_ENERGY 0 1
+NebulaPlus_U74_ENERGY 0 1
+NebulaPlus_U75_ENERGY 0 1
+NebulaPlus_U76_ENERGY 0 1
+NebulaPlus_U77_ENERGY 0 1
+NebulaPlus_U78_ENERGY 0 1
+NebulaPlus_U79_ENERGY 0 1
+NebulaPlus_U80_ENERGY 0 1
+NebulaPlus_U81_ENERGY 0 1
+NebulaPlus_U82_ENERGY 0 1
+NebulaPlus_U83_ENERGY 0 1
+NebulaPlus_U84_ENERGY 0 1
+NebulaPlus_U85_ENERGY 0 1
+NebulaPlus_U86_ENERGY 0 1
+NebulaPlus_U87_ENERGY 0 1
+NebulaPlus_U88_ENERGY 0 1
+NebulaPlus_U89_ENERGY 0 1
+NebulaPlus_U90_ENERGY 0 1
+
diff --git a/Projects/NebulaPlus/calibration/NebulaPlus_Tdiff_Offset.cal b/Projects/NebulaPlus/calibration/NebulaPlus_Tdiff_Offset.cal
new file mode 100644
index 0000000000000000000000000000000000000000..24c21ef2b51b23ca4bf7124bf914ab7fd78adef7
--- /dev/null
+++ b/Projects/NebulaPlus/calibration/NebulaPlus_Tdiff_Offset.cal
@@ -0,0 +1,92 @@
+NebulaPlus_Tdiff_Offset_1 5.17288
+NebulaPlus_Tdiff_Offset_2 0.568133
+NebulaPlus_Tdiff_Offset_3 2.47937
+NebulaPlus_Tdiff_Offset_4 3.43329
+NebulaPlus_Tdiff_Offset_5 2.26801
+NebulaPlus_Tdiff_Offset_6 -3.03789
+NebulaPlus_Tdiff_Offset_7 4.90289
+NebulaPlus_Tdiff_Offset_8 3.9337
+NebulaPlus_Tdiff_Offset_9 -4.71495
+NebulaPlus_Tdiff_Offset_10 1.5473
+NebulaPlus_Tdiff_Offset_11 3.9492
+NebulaPlus_Tdiff_Offset_12 0.99885
+NebulaPlus_Tdiff_Offset_13 -5.47822
+NebulaPlus_Tdiff_Offset_14 5.5472
+NebulaPlus_Tdiff_Offset_15 2.048
+NebulaPlus_Tdiff_Offset_16 -0.440609
+NebulaPlus_Tdiff_Offset_17 -1.87889
+NebulaPlus_Tdiff_Offset_18 1.06144
+NebulaPlus_Tdiff_Offset_19 2.83913
+NebulaPlus_Tdiff_Offset_20 2.55256
+NebulaPlus_Tdiff_Offset_21 1.30455
+NebulaPlus_Tdiff_Offset_22 0.996235
+NebulaPlus_Tdiff_Offset_23 4.05148
+NebulaPlus_Tdiff_Offset_24 -5.01333
+NebulaPlus_Tdiff_Offset_25 -5.04853
+NebulaPlus_Tdiff_Offset_26 -6.92471
+NebulaPlus_Tdiff_Offset_27 -6.88351
+NebulaPlus_Tdiff_Offset_28 0.96321
+NebulaPlus_Tdiff_Offset_29 3.12615
+NebulaPlus_Tdiff_Offset_30 -5.6342
+NebulaPlus_Tdiff_Offset_31 -0.798026
+NebulaPlus_Tdiff_Offset_32 0.287694
+NebulaPlus_Tdiff_Offset_33 1.66875
+NebulaPlus_Tdiff_Offset_34 -6.99295
+NebulaPlus_Tdiff_Offset_35 -3.19359
+NebulaPlus_Tdiff_Offset_36 0.02765
+NebulaPlus_Tdiff_Offset_37 -0.880016
+NebulaPlus_Tdiff_Offset_38 4.7604
+NebulaPlus_Tdiff_Offset_39 -3.06803
+NebulaPlus_Tdiff_Offset_40 0.907779
+NebulaPlus_Tdiff_Offset_41 -4.67336
+NebulaPlus_Tdiff_Offset_42 0.829625
+NebulaPlus_Tdiff_Offset_43 0.28951
+NebulaPlus_Tdiff_Offset_44 3.63011
+NebulaPlus_Tdiff_Offset_45 0.932612
+NebulaPlus_Tdiff_Offset_46 -7.92853
+NebulaPlus_Tdiff_Offset_47 -0.989877
+NebulaPlus_Tdiff_Offset_48 3.52937
+NebulaPlus_Tdiff_Offset_49 0.236056
+NebulaPlus_Tdiff_Offset_50 -2.87001
+NebulaPlus_Tdiff_Offset_51 1.85101
+NebulaPlus_Tdiff_Offset_52 -4.24166
+NebulaPlus_Tdiff_Offset_53 4.159
+NebulaPlus_Tdiff_Offset_54 5.85506
+NebulaPlus_Tdiff_Offset_55 3.56968
+NebulaPlus_Tdiff_Offset_56 -0.89544
+NebulaPlus_Tdiff_Offset_57 -0.826875
+NebulaPlus_Tdiff_Offset_58 4.09274
+NebulaPlus_Tdiff_Offset_59 -1.75094
+NebulaPlus_Tdiff_Offset_60 0.493957
+NebulaPlus_Tdiff_Offset_61 -0.260756
+NebulaPlus_Tdiff_Offset_62 6.46713
+NebulaPlus_Tdiff_Offset_63 -4.96601
+NebulaPlus_Tdiff_Offset_64 -5.46893
+NebulaPlus_Tdiff_Offset_65 11.4451
+NebulaPlus_Tdiff_Offset_66 1.35551
+NebulaPlus_Tdiff_Offset_67 1.1528
+NebulaPlus_Tdiff_Offset_68 0.0792745
+NebulaPlus_Tdiff_Offset_69 -0.0368659
+NebulaPlus_Tdiff_Offset_70 5.84517
+NebulaPlus_Tdiff_Offset_71 -2.02714
+NebulaPlus_Tdiff_Offset_72 3.68631
+NebulaPlus_Tdiff_Offset_73 -5.92629
+NebulaPlus_Tdiff_Offset_74 -3.25264
+NebulaPlus_Tdiff_Offset_75 -4.746
+NebulaPlus_Tdiff_Offset_76 3.08691
+NebulaPlus_Tdiff_Offset_77 -5.22465
+NebulaPlus_Tdiff_Offset_78 1.80784
+NebulaPlus_Tdiff_Offset_79 3.56686
+NebulaPlus_Tdiff_Offset_80 -5.3148
+NebulaPlus_Tdiff_Offset_81 -6.70568
+NebulaPlus_Tdiff_Offset_82 -0.436624
+NebulaPlus_Tdiff_Offset_83 3.85383
+NebulaPlus_Tdiff_Offset_84 4.01968
+NebulaPlus_Tdiff_Offset_85 0.279455
+NebulaPlus_Tdiff_Offset_86 0.456427
+NebulaPlus_Tdiff_Offset_87 3.23678
+NebulaPlus_Tdiff_Offset_88 0.784784
+NebulaPlus_Tdiff_Offset_89 -5.3909
+NebulaPlus_Tdiff_Offset_90 0
+NebulaPlus_Tdiff_Offset_91 3.12457
+NebulaPlus_Tdiff_Offset_92 0
diff --git a/Projects/NebulaPlus/calibration/NebulaPlus_Up_Energy.cal b/Projects/NebulaPlus/calibration/NebulaPlus_Up_Energy.cal
new file mode 100644
index 0000000000000000000000000000000000000000..77372aef6c2ff5914e4c177473c50884ecc713ad
--- /dev/null
+++ b/Projects/NebulaPlus/calibration/NebulaPlus_Up_Energy.cal
@@ -0,0 +1,91 @@
+NebulaPlus_U1_ENERGY 0 1
+NebulaPlus_U2_ENERGY 0 1
+NebulaPlus_U3_ENERGY 0 1
+NebulaPlus_U4_ENERGY 0 1
+NebulaPlus_U5_ENERGY 0 1
+NebulaPlus_U6_ENERGY 0 1
+NebulaPlus_U7_ENERGY 0 1
+NebulaPlus_U8_ENERGY 0 1
+NebulaPlus_U9_ENERGY 0 1
+NebulaPlus_U10_ENERGY 0 1
+NebulaPlus_U11_ENERGY 0 1
+NebulaPlus_U12_ENERGY 0 1
+NebulaPlus_U13_ENERGY 0 1
+NebulaPlus_U14_ENERGY 0 1
+NebulaPlus_U15_ENERGY 0 1
+NebulaPlus_U16_ENERGY 0 1
+NebulaPlus_U17_ENERGY 0 1
+NebulaPlus_U18_ENERGY 0 1
+NebulaPlus_U19_ENERGY 0 1
+NebulaPlus_U20_ENERGY 0 1
+NebulaPlus_U21_ENERGY 0 1
+NebulaPlus_U22_ENERGY 0 1
+NebulaPlus_U23_ENERGY 0 1
+NebulaPlus_U24_ENERGY 0 1
+NebulaPlus_U25_ENERGY 0 1
+NebulaPlus_U26_ENERGY 0 1
+NebulaPlus_U27_ENERGY 0 1
+NebulaPlus_U28_ENERGY 0 1
+NebulaPlus_U29_ENERGY 0 1
+NebulaPlus_U30_ENERGY 0 1
+NebulaPlus_U31_ENERGY 0 1
+NebulaPlus_U32_ENERGY 0 1
+NebulaPlus_U33_ENERGY 0 1
+NebulaPlus_U34_ENERGY 0 1
+NebulaPlus_U35_ENERGY 0 1
+NebulaPlus_U36_ENERGY 0 1
+NebulaPlus_U37_ENERGY 0 1
+NebulaPlus_U38_ENERGY 0 1
+NebulaPlus_U39_ENERGY 0 1
+NebulaPlus_U40_ENERGY 0 1
+NebulaPlus_U41_ENERGY 0 1
+NebulaPlus_U42_ENERGY 0 1
+NebulaPlus_U43_ENERGY 0 1
+NebulaPlus_U44_ENERGY 0 1
+NebulaPlus_U45_ENERGY 0 1
+NebulaPlus_U46_ENERGY 0 1
+NebulaPlus_U47_ENERGY 0 1
+NebulaPlus_U48_ENERGY 0 1
+NebulaPlus_U49_ENERGY 0 1
+NebulaPlus_U50_ENERGY 0 1
+NebulaPlus_U51_ENERGY 0 1
+NebulaPlus_U52_ENERGY 0 1
+NebulaPlus_U53_ENERGY 0 1
+NebulaPlus_U54_ENERGY 0 1
+NebulaPlus_U55_ENERGY 0 1
+NebulaPlus_U56_ENERGY 0 1
+NebulaPlus_U57_ENERGY 0 1
+NebulaPlus_U58_ENERGY 0 1
+NebulaPlus_U59_ENERGY 0 1
+NebulaPlus_U60_ENERGY 0 1
+NebulaPlus_U61_ENERGY 0 1
+NebulaPlus_U62_ENERGY 0 1
+NebulaPlus_U63_ENERGY 0 1
+NebulaPlus_U64_ENERGY 0 1
+NebulaPlus_U65_ENERGY 0 1
+NebulaPlus_U66_ENERGY 0 1
+NebulaPlus_U67_ENERGY 0 1
+NebulaPlus_U68_ENERGY 0 1
+NebulaPlus_U69_ENERGY 0 1
+NebulaPlus_U70_ENERGY 0 1
+NebulaPlus_U71_ENERGY 0 1
+NebulaPlus_U72_ENERGY 0 1
+NebulaPlus_U73_ENERGY 0 1
+NebulaPlus_U74_ENERGY 0 1
+NebulaPlus_U75_ENERGY 0 1
+NebulaPlus_U76_ENERGY 0 1
+NebulaPlus_U77_ENERGY 0 1
+NebulaPlus_U78_ENERGY 0 1
+NebulaPlus_U79_ENERGY 0 1
+NebulaPlus_U80_ENERGY 0 1
+NebulaPlus_U81_ENERGY 0 1
+NebulaPlus_U82_ENERGY 0 1
+NebulaPlus_U83_ENERGY 0 1
+NebulaPlus_U84_ENERGY 0 1
+NebulaPlus_U85_ENERGY 0 1
+NebulaPlus_U86_ENERGY 0 1
+NebulaPlus_U87_ENERGY 0 1
+NebulaPlus_U88_ENERGY 0 1
+NebulaPlus_U89_ENERGY 0 1
+NebulaPlus_U90_ENERGY 0 1
+
diff --git a/Projects/NebulaPlus/cmake_install.cmake b/Projects/NebulaPlus/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..93b19c768b6e7f17709bdd02c9caf0564cf60fb9
--- /dev/null
+++ b/Projects/NebulaPlus/cmake_install.cmake
@@ -0,0 +1,49 @@
+# Install script for directory: /home/expand/Experiments/Test_SAMURAI/nptool/Projects/NebulaPlus
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+ set(CMAKE_INSTALL_PREFIX "/usr/local")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+ if(BUILD_TYPE)
+ string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+ CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+ else()
+ set(CMAKE_INSTALL_CONFIG_NAME "Release")
+ endif()
+ message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+ if(COMPONENT)
+ message(STATUS "Install component: \"${COMPONENT}\"")
+ set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+ else()
+ set(CMAKE_INSTALL_COMPONENT)
+ endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+ set(CMAKE_INSTALL_SO_NO_EXE "1")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+ set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+if(CMAKE_INSTALL_COMPONENT)
+ set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+else()
+ set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+ "${CMAKE_INSTALL_MANIFEST_FILES}")
+file(WRITE "/home/expand/Experiments/Test_SAMURAI/nptool/Projects/NebulaPlus/${CMAKE_INSTALL_MANIFEST}"
+ "${CMAKE_INSTALL_MANIFEST_CONTENT}")
diff --git a/Projects/NebulaPlus/energy_loss/.gitignore b/Projects/NebulaPlus/energy_loss/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Projects/NebulaPlus/flat.txt b/Projects/NebulaPlus/flat.txt
new file mode 100644
index 0000000000000000000000000000000000000000..09b15128730aecce2f1126bf7937af827eba3712
--- /dev/null
+++ b/Projects/NebulaPlus/flat.txt
@@ -0,0 +1,3 @@
+0 1
+90 1
+180 1
diff --git a/Projects/NebulaPlus/macro/.gitignore b/Projects/NebulaPlus/macro/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Projects/NebulaPlus/macro/FitTrack.C b/Projects/NebulaPlus/macro/FitTrack.C
new file mode 100644
index 0000000000000000000000000000000000000000..3801c4b3e51b43c338f9c1ad5b10443962eaf630
--- /dev/null
+++ b/Projects/NebulaPlus/macro/FitTrack.C
@@ -0,0 +1,157 @@
+TChain* chain=NULL ;
+
+////////////////////////////////////////////////////////////////////////////////
+void LoadChain(){
+ chain = new TChain("PhysicsTree");
+ //chain->Add("./root/analysis/testmult16.root");
+ chain->Add("./root/analysis/run_38_0001.root");
+}
+double fpol1(double* x, double* par){
+ double result = par[0]+par[1]*x[0];
+ return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void FitTrack(){
+ LoadChain();
+
+ TNebulaPlusPhysics* m_NebulaPlus = new TNebulaPlusPhysics();
+ chain->SetBranchAddress("NebulaPlus", &m_NebulaPlus);
+ Long64_t nentries = chain->GetEntries();
+ TH1F* h = new TH1F("h","h",300,0,300);
+ TH1F* hTheta = new TH1F("hTheta","hTheta",100,0,100);
+ TH1F** hdT = new TH1F*[90];
+ for ( int i=0; i<90; i++) {
+ hdT[i]=new TH1F(Form("hdT%d",i+1),Form("TOF%d - TOF%d:TOF(ns)",i+1,i+2),400,-10,10);
+ }
+
+ TCanvas* c = new TCanvas("c","c",0,0,700,700);
+ c->cd();
+ gStyle->SetOptFit(111111111);
+ h->GetXaxis()->SetRangeUser(-300,300);
+ h->GetYaxis()->SetRangeUser(-300,300);
+ double Theta;
+
+ for(Long64_t i = 0; i < nentries; i++){
+ chain->GetEntry(i);
+ int mult= m_NebulaPlus->DetectorNumber.size();
+
+ /// build flag to select single layer event ///
+ double tmp=-99;
+ bool multilayer=false;
+ for(int j=0;j<mult;j++){
+ if(j==0) tmp = m_NebulaPlus->PosZ[j];
+ if(m_NebulaPlus->PosZ[j]!=tmp) multilayer=true;
+ }
+
+ if(!multilayer){
+ if(mult>6){
+
+ ///////////////////////////////////////////////
+ //// Track construction and Fit in Y vs X /////
+ ///////////////////////////////////////////////
+ TGraph* g = new TGraph(
+ mult,
+ &(m_NebulaPlus->PosX[0]),
+ &(m_NebulaPlus->PosY[0])
+ );
+ g->SetMarkerStyle(3);
+ h->Draw("");
+ g->Draw("Psame");
+
+ TF1* toto = new TF1("f1",fpol1,0,300,2);
+ g->Fit("f1","QR");
+ double offset = toto->GetParameter(0);
+ double slope = toto->GetParameter(1);
+
+ //std::cout << offset << std::endl;;
+ //std::cout << slope << std::endl;;
+
+ TVector2 a(0,offset);
+ TVector2 b(1,offset+slope);
+ TVector2 c = b-a;
+ Theta = fabs(TMath::ATan(c.Y()/c.X())*180./TMath::Pi());
+ std::cout << Theta << std::endl;
+ hTheta->Fill(Theta);
+ gPad->WaitPrimitive();
+
+ ///////////////////////////////////////////////
+ //// Time analysis between adjacent bars //////
+ ///////////////////////////////////////////////
+
+ vector<int> ID(mult);
+ vector<int> IDsort(mult);
+ vector<int> idx(mult);
+ vector<double> T(mult);
+ double dT=0;
+
+ ID = m_NebulaPlus->DetectorNumber;
+
+ //std::cout << "---------" << std::endl;
+ //std::cout << ID[0] << std::endl;
+ //std::cout << m_NebulaPlus->DetectorNumber[0] << std::endl;
+ TMath::Sort(mult,&ID[0],&idx[0],false);
+
+ //std::cout << "---------" << std::endl;
+
+ for(int k=0;k<mult;k++){
+ T[k] = m_NebulaPlus->TOF[idx[k]];
+ IDsort[k] = m_NebulaPlus->DetectorNumber[idx[k]];
+ //if(k=0) refT = T[0]; refID = ID[0];
+ if(k>0 && IDsort[k-1]==IDsort[k]-1 ){
+ // if(T[k]>T[k-1]) dT = T[k]-T[k-1];
+ // if(T[k]<T[k-1]) dT = T[k-1]-T[k];
+
+ dT = T[k]-T[k-1];
+ hdT[IDsort[k-1]]->Fill(dT);
+
+ //std::cout <<IDsort[k]<< "\t" << hdT[IDsort[k-1]]->GetName() << "\t" << dT<< std::endl;
+ }
+ }
+
+
+
+ }
+ }
+
+ }
+
+ c->cd();
+ hTheta->Draw();
+ c->Print("TOF.pdf[");
+ TGraph *res1 = new TGraph(90);
+ TGraph *res2 = new TGraph(90);
+ res1->SetName("res1");
+ res2->SetName("res2");
+ for (int i=0; i<90; i++){
+ TF1* f_gauss = new TF1("f_gauss","gaus(0)+gaus(3)",-10,10);
+ double par[6] = {hdT[i]->GetMaximum(), hdT[i]->GetMean()-.5, 0.5,hdT[i]->GetMaximum(), hdT[i]->GetMean()+0.5 , 0.5 };
+ f_gauss->SetParameters(par);
+ f_gauss->SetNpx(1000);
+ hdT[i]->Fit(f_gauss,"Q");
+ c->Print("TOF.pdf");
+ res1->SetPoint(i,i+1,TMath::Abs(f_gauss->GetParameter(2)));
+ res2->SetPoint(i,i+1,TMath::Abs(f_gauss->GetParameter(5)));
+
+ }
+ res1->SetMarkerStyle(kStar);
+ res1->SetMarkerColor(kRed);
+
+
+ res2->SetMarkerStyle(kStar);
+ res2->SetMarkerColor(kBlue);
+ TMultiGraph* mg = new TMultiGraph();
+ mg->Add(res1,"p");
+ mg->Add(res2,"p");
+ mg->SetTitle(" ; ID ; sigma value");
+ mg->Draw("a");
+
+
+ c->Print("TOF.pdf");
+ c->Print("TOF.pdf]");
+
+
+
+
+
+}
diff --git a/Projects/NebulaPlus/macro/ShowTrack.C b/Projects/NebulaPlus/macro/ShowTrack.C
new file mode 100644
index 0000000000000000000000000000000000000000..d62e352c7c7260d594aa636324647e032f08e4b7
--- /dev/null
+++ b/Projects/NebulaPlus/macro/ShowTrack.C
@@ -0,0 +1,40 @@
+TChain* chain=NULL ;
+
+////////////////////////////////////////////////////////////////////////////////
+void LoadChain(){
+ chain = new TChain("PhysicsTree");
+ chain->Add("./root/analysis/testmult16.root");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void ShowTrack(){
+ LoadChain();
+ TH1 *h[20];
+ TGraph *g[20];
+ string command;
+ string histname;
+
+ TCanvas* c1 = new TCanvas("YX","YX",0,0,1200,600);
+ TCanvas* c2 = new TCanvas("ZX","ZX",0,0,1200,600);
+ c1->Divide(4,4);
+ c2->Divide(4,4);
+ for(int i=0; i<16; i++){
+ c1->cd(i+1);
+ command ="PosY:PosX>>hYX_"+to_string(i)+"(100,0,300,400,-200,200)";
+ chain->Draw(command.c_str(),"","",1,i);
+ //histname="hYX_"+to_string(i);
+ //h[i]= (TH1F*) gDirectory->FindObjectAny(histname.c_str());
+ //g[i] = new TGraph(h[i]);
+ //g[i]->SetMarkerStyle(3) ;
+ //g[i]->Draw("AP") ;
+
+ c2->cd(i+1);
+ command ="PosZ/10.:PosX>>hZX_"+to_string(i)+"(100,0,300,120,-10,110)";
+ chain->Draw(command.c_str(),"","*",1,i);
+ //histname="hWall2_"+to_string(i);
+ //h[i-1]= (TH1F*) gDirectory->FindObjectAny(histname.c_str());
+ //h[i-1]->SetMarkerColor(kRed) ;
+
+ //gPad->WaitPrimitive();
+ }
+}
diff --git a/Projects/NebulaPlus/macro/TdiffCal.C b/Projects/NebulaPlus/macro/TdiffCal.C
new file mode 100644
index 0000000000000000000000000000000000000000..b495a48e01ffd753c64ae10bce3759d8453802bd
--- /dev/null
+++ b/Projects/NebulaPlus/macro/TdiffCal.C
@@ -0,0 +1,45 @@
+TFile* file=NULL ;
+
+////////////////////////////////////////////////////////////////////////////////
+void LoadFile(){
+ file = new TFile("../root/analysis/hTdiff_ID_run18.root");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TdiffCal(bool savehist=true){
+ LoadFile();
+ TH2F* hQu_ID = (TH2F*) gDirectory->FindObjectAny("hTdiff_ID");
+
+ TCanvas* c1 = new TCanvas("Raw","Raw",0,0,1200,600);
+ c1->cd();
+ //c1->SetLogy();
+
+ TH1F* hQu[90];
+ Double_t mean=0;
+ string histname;
+ bool found = false;
+
+ //RANGE FOR THE MUON PEAK SEARCH
+ double range_inf= -30;
+ double range_sup= 30;
+
+ ofstream peaks_file;
+ peaks_file.open("tmp.txt");
+ for(int i=1; i<93; i++){
+
+ histname = "hQu_"+to_string(i);
+ cout<<i<<"histname\t"<<histname<<endl;
+ hQu_ID->ProjectionY(histname.c_str(),i+1,i+1);
+ hQu[i-1] = (TH1F*) gDirectory->FindObjectAny(histname.c_str());
+ hQu[i-1]->Draw("");
+ hQu[i-1]->SetTitle(histname.c_str());
+ hQu[i-1]->GetXaxis()->SetRangeUser(range_inf,range_sup);
+ mean = hQu[i-1]->GetMean(1);
+ //if(!found) cout<<"BarID:"<<i<<"UP, problem in finding peaks"<<endl;
+ //gPad->WaitPrimitive();
+ peaks_file<<"NebulaPlus_Tdiff_Offset_"<<i<<"\t"<<mean<<endl;
+ cout<<i<<"mean:\t"<<mean<<