Skip to content
Snippets Groups Projects
Commit 69444564 authored by Matthias Steinke's avatar Matthias Steinke
Browse files

added Setup package

parent 7a04ebec
No related branches found
No related tags found
No related merge requests found
...@@ -76,6 +76,7 @@ add_subdirectory (qft++) ...@@ -76,6 +76,7 @@ add_subdirectory (qft++)
add_subdirectory (Utils) add_subdirectory (Utils)
add_subdirectory (ErrLogger) add_subdirectory (ErrLogger)
add_subdirectory (Particle) add_subdirectory (Particle)
add_subdirectory (Setup)
add_subdirectory (Examples/qft++) add_subdirectory (Examples/qft++)
......
CMAKE_MINIMUM_REQUIRED(VERSION 2.4.3 FATAL_ERROR)
set(PACKAGE_NAME Setup)
MESSAGE("cmake installation for package: " ${PACKAGE_NAME})
set(INCLUDE_DIRECTORIES
${CMAKE_SOURCE_DIR}
)
include_directories( ${INCLUDE_DIRECTORIES})
AUX_SOURCE_DIRECTORY("." SRC)
Set(CCSRC "")
FOREACH (THEFILE ${SRC})
IF (NOT ${THEFILE} MATCHES "(.*)App(.*)")
SET (CCSRC ${CCSRC} ${THEFILE})
ENDIF()
ENDFOREACH(THEFILE)
# BUILD_SHARED_LIBS controls the behavior of ADD_LIBRARY if STATIC/SHARED omitted
IF( PAWIAN_STATIC )
ADD_LIBRARY ( ${PACKAGE_NAME} STATIC ${CCSRC} )
ELSE()
ADD_LIBRARY ( ${PACKAGE_NAME} SHARED ${CCSRC} )
ENDIF( PAWIAN_STATIC )
INSTALL (TARGETS ${PACKAGE_NAME} DESTINATION ${CMAKE_BINARY_DIR}/lib)
if(COMMAND cmake_policy)
cmake_policy(SET CMP0003 NEW)
endif(COMMAND cmake_policy)
SET (EXECUTABLENAME SetupTestApp)
ADD_EXECUTABLE( ${EXECUTABLENAME}
SetupTestApp.cc
)
target_link_libraries(${EXECUTABLENAME} Setup)
target_link_libraries(${EXECUTABLENAME} Particle)
target_link_libraries(${EXECUTABLENAME} ErrLogger)
target_link_libraries(${EXECUTABLENAME} Utils)
INSTALL ( TARGETS ${EXECUTABLENAME} DESTINATION bin/${EXECUTABLENAME})
#ifndef SETUPDATA_HH
#define SETUPDATA_HH
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/variant/recursive_variant.hpp>
#include <boost/foreach.hpp>
#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#include <vector>
namespace setupData
{
namespace fusion = boost::fusion;
namespace phoenix = boost::phoenix;
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
///////////////////////////////////////////////////////////////////////////
// Our mini DECAY tree representation
///////////////////////////////////////////////////////////////////////////
struct decay_tree;
typedef
boost::variant<
boost::recursive_wrapper<decay_tree>
, std::string
>
decay_node;
struct decay_tree
{
std::string name; // mother particle name
std::vector<decay_node> children; // children
std::vector<std::string> addParticle;
std::vector<std::string> cloneParticle;
std::vector<std::string> modParticle;
std::vector<std::string> beamInput;
std::vector<std::string> mcInput;
std::vector<std::string> defineTuple;
std::vector<std::string> fitVars;
std::vector<std::string> initialProps;
};
}
// We need to tell fusion about our setup struct
// to make it a first-class fusion citizen
BOOST_FUSION_ADAPT_STRUCT(
setupData::decay_tree,
(std::string, name)
(std::vector<setupData::decay_node>, children)
(std::vector<std::string>, addParticle)
(std::vector<std::string>, cloneParticle)
(std::vector<std::string>, modParticle)
(std::vector<std::string>, beamInput)
(std::vector<std::string>, mcInput)
(std::vector<std::string>, defineTuple)
(std::vector<std::string>, fitVars)
(std::vector<std::string>, initialProps)
)
namespace setupData
{
///////////////////////////////////////////////////////////////////////////
// Print out the mini decay tree
///////////////////////////////////////////////////////////////////////////
int const tabsize = 4;
void tab(int indent)
{
for (int i = 0; i < indent; ++i)
std::cout << ' ';
}
struct decay_tree_printer
{
decay_tree_printer(int indent = 0)
: indent(indent)
{
}
void operator()(decay_tree const& decay) const;
int indent;
};
struct decay_node_printer : boost::static_visitor<>
{
decay_node_printer(int indent = 0)
: indent(indent)
{
}
void operator()(decay_tree const& decay) const
{
decay_tree_printer(indent+tabsize)(decay);
}
void operator()(std::string const& text) const
{
tab(indent+tabsize);
std::cout << "text: \"" << text << '"' << std::endl;
}
int indent;
};
void decay_tree_printer::operator()(decay_tree const& decay) const
{
tab(indent);
std::cout << "tag: " << decay.name << std::endl;
tab(indent);
std::cout << '{' << std::endl;
BOOST_FOREACH(decay_node const& node, decay.children)
{
boost::apply_visitor(decay_node_printer(indent), node);
}
tab(indent);
std::vector<std::string>::const_iterator iter;
iter = decay.addParticle.begin();
while (iter != decay.addParticle.end()) {
std::cout << "new particle: " << *iter << std::endl;
++iter;
}
iter = decay.cloneParticle.begin();
while (iter != decay.cloneParticle.end()) {
std::cout << "cloned particle: " << *iter << std::endl;
++iter;
}
iter = decay.modParticle.begin();
while (iter != decay.modParticle.end()) {
std::cout << "modified particle: " << *iter << std::endl;
++iter;
}
std::cout << '}' << std::endl;
}
///////////////////////////////////////////////////////////////////////////
// Our mini DECAY grammar definition
///////////////////////////////////////////////////////////////////////////
//[tutorial_decay1_grammar
template <typename Iterator>
struct setup_file_grammar : qi::grammar<Iterator, decay_tree(), ascii::space_type>
{
setup_file_grammar() : setup_file_grammar::base_type(decay)
{
using qi::lit;
using qi::lexeme;
using ascii::char_;
using ascii::string;
using namespace qi::labels;
using phoenix::at_c;
using phoenix::push_back;
using boost::phoenix::ref;
restOfLine = lexeme[*(char_ -'\n') [_val += _1]];
comment = (char_('#') >> lexeme[*(char_ -'\n')]);
particleName = lexeme[+(char_('!','z') -',') [_val += _1]];
decNode = (decay | particleName);
goesTo = char_('-') >> char_('>');
decay = +( comment ||
"addParticle" >> restOfLine[push_back(at_c<2>(_val), _1)] ||
"cloneParticle" >> restOfLine[push_back(at_c<3>(_val), _1)] ||
"modParticle" >> restOfLine[push_back(at_c<4>(_val), _1)] ||
"beamInput" >> restOfLine[push_back(at_c<5>(_val), _1)] ||
"mcInput" >> restOfLine[push_back(at_c<6>(_val), _1)] ||
"defineTuple" >> restOfLine[push_back(at_c<7>(_val), _1)] ||
"fitVariables" >> restOfLine[push_back(at_c<8>(_val), _1)] ||
"initialProperties" >> restOfLine[push_back(at_c<9>(_val), _1)] ||
( char_('{')
>> (decay[push_back(at_c<1>(_val), _1)] || particleName[at_c<0>(_val) = _1])
>> goesTo
>> decNode [push_back(at_c<1>(_val), _1)]
>> ','
>> decNode [push_back(at_c<1>(_val), _1)]
>> char_('}') )
);
}
qi::rule<Iterator, decay_tree(), ascii::space_type> decay;
qi::rule<Iterator, decay_node(), ascii::space_type> decNode;
qi::rule<Iterator, std::string(), ascii::space_type> goesTo;
qi::rule<Iterator, std::string(), ascii::space_type> comment;
qi::rule<Iterator, std::string(), ascii::space_type> restOfLine;
qi::rule<Iterator, std::string(), ascii::space_type> particleName;
};
}
#endif
#include "Setup/SetupParser.hh"
// Particle.hh defines ParticleData struct
#include "Particle/Particle.hh"
#include "Particle/ParticleTable.hh"
// SetupData.hh has all the boost includes
#include "SetupData.hh"
#include "ErrLogger/ErrLineLog.hh"
#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
SetupParser::SetupParser()
{
}
SetupParser::~SetupParser()
{
}
bool SetupParser::parse(std::string& fileName)
{
std::ifstream in(fileName.c_str(), std::ios_base::in);
if (!in) {
ErrMsg(fatal) << "Error: Could not open input file: "
<< fileName << endmsg;
return 1;
}
std::string storage; // We will read the contents here.
in.unsetf(std::ios::skipws); // No white space skipping!
std::copy(std::istream_iterator<char>(in),
std::istream_iterator<char>(),
std::back_inserter(storage));
typedef setupData::setup_file_grammar<std::string::const_iterator> setup_file_grammar;
setup_file_grammar setupGrammar; // Our grammar
setupData::decay_tree ast; // Our setup
using boost::spirit::ascii::space;
std::string::const_iterator iter = storage.begin();
std::string::const_iterator end = storage.end();
bool r = phrase_parse(iter, end, setupGrammar, space, ast);
if (r && iter == end) {
ErrMsg(trace) << "\n\n"
<< "-------------------------\n"
<< "Parsing succeeded\n"
<< "-------------------------\n" << endmsg;
setupData::decay_tree_printer printer;
printer(ast);
return true; // true means success
}
else {
std::string::const_iterator some = iter+30;
std::string context(iter, (some>end)?end:some);
ErrMsg(error) << "\n\n"
<< "-------------------------\n"
<< "Parsing failed\n"
<< "stopped at: \": " << context << "...\"\n"
<< "-------------------------\n" << endmsg;
return false;
}
return false; // success
}
#ifndef SETUPPARSER_HH
#define SETUPPARSER_HH
#include <string>
class SetupParser
{
public:
SetupParser();
~SetupParser();
bool parse(std::string& fileName);
};
#endif
#include "Particle/ParticleTable.hh"
#include "Particle/Particle.hh"
#include "Particle/PdtParser.hh"
#include "Setup/SetupParser.hh"
#include "ErrLogger/ErrLineLog.hh"
#include <iostream>
#include <string>
int main()
{
ErrLineLog myLogger(ErrLog::debugging);
ParticleTable pTable;
PdtParser parser;
std::string theSourcePath=getenv("CMAKE_SOURCE_DIR");
std::string pdtFile(theSourcePath+"/Particle/pdt.table");
if (parser.parse(pdtFile, pTable)) {
pTable.print(std::cout);
} else {
ErrMsg(fatal) << "Error: could not parse " << pdtFile << endmsg;
exit(1);
}
SetupParser setupP;
std::string setupFile(theSourcePath + "/Setup/test.setup");
if (setupP.parse(setupFile)) {
ErrMsg(trace) << "setup parsed successfully" << endmsg;
} else {
ErrMsg(fatal) << "Error: could not parse " << setupFile << endmsg;
exit(1);
}
return 0;
}
#
# a comment in a sample setup file
#
# {} marks a decay chain
{ ppbar -> {partB -> myPi+, pi-} , {partC -> partD, partE} }
{ ppbar -> {partB -> myPi+, pi-} , {partX -> partD, partE} }
{ ppbar -> {partB -> myPi+, pi-} , {partY -> partD, partE} }
{ ppbar -> {partB -> myPi+, pi-} , {partZ -> partD, partE} }
# set properties of initial state: L, M = Lz,
initialProperties L=0,5 M=1,-1
# define what should be varied in the fit: width, mass, amplitude, phase
fitVariables partB(amplitude, phase, mass) partC(amplitude, phase, width, mass)
# define a new particle in the syntax used in our pdt table
# type name texName 3*Q 2*J P C G I I3 S C mass width dynFuntion [comment]
addParticle Meson partC(1270) partC(1270) 0 2 -1 -1 1 1 0 0 0 1.270 0.300 RelBWBlattWk [glueball? hybrid?]
# derive a new particle from an existing one and modify it: mass, width, JPC, dynFunction
cloneParticle myPi+ pi+
modParticle myPi+ mass=142.3+0.5-0.4
# define the columns in the input tuples
defineTuple myPi+ pi- partD partE
# set the input files for beam and mc data
beamInput beam1.root
beamInput beam2.root
beamInput beam3.root beam4.root
mcInput mc1.root mc2.root
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment