/* * Copyright (C) 2007-2009, CompHEP Collaboration * Author: Alexander Sherstnev *------------------------------------------------------ */ #include #include #include #include #ifdef LIBXML #include #include #endif #include "service2/include/kfcodes.h" #include "LesHouches.h" #include "lhaef.h" #include "tag_reader.h" #include "tag_parser.h" #include "event_reader.h" #include "lhef_routines.h" static int nevents[MAX_FILE_EVENT]; static double cs[MAX_FILE_EVENT]; static double cserr[MAX_FILE_EVENT]; static long nposition[MAX_FILE_EVENT]; static char final_state_name[1024]; static char subproc_name[1024]; static int tot_proc_num; static int the_pbeam[2]; static double the_ebeam[2]; static int the_PDFLIBgroup[2]; static int the_PDFLIBset[2]; static char the_version[256]; static double tot_cs = 0.0; static double tot_cserr = 0.0; void set_cs (double c1, double c2) { tot_cs = c1; tot_cserr = c2; return; } int set_final_numbers (int n, int size, double cs1, double cserr1, char check[128]) { lhaef_file lhafile; void * hepml_header = init_lhaef_document (); tot_cs = cs1; tot_cserr = cserr1; lhafile.nevents = n; lhafile.size = size; lhafile.cross_section = cs1; lhafile.cross_section_upper_error = cserr1; lhafile.cross_section_lower_error = cserr1; strcpy (lhafile.cross_section_unit, "pb"); strcpy (lhafile.check_sum, check); strcpy (lhafile.check_sum_type, "md5"); return set_file_description (hepml_header, &lhafile);; } #ifdef LIBXML static int fill_base_hepml = 1; static const xmlChar * nameStr = (const xmlChar *)"name"; static const xmlChar * valueStr = (const xmlChar *)"value"; static const xmlChar * plainStr = (const xmlChar *)"plain"; static const xmlChar * latexStr = (const xmlChar *)"latex"; static const xmlChar * symbStr = (const xmlChar *)"notation"; static const xmlChar * subproclistStr = (const xmlChar *)"subprocesses"; static const xmlChar * subprocStr = (const xmlChar *)"subprocess"; static const xmlChar * cutSetStr = (const xmlChar *)"cutSet"; static const xmlChar * descriptionStr = (const xmlChar *)"description"; static const xmlChar * processStr = (const xmlChar *)"process"; static const xmlChar * filelistStr = (const xmlChar *)"files"; static const xmlChar * fileStr = (const xmlChar *)"file"; static const xmlChar * cutlistStr = (const xmlChar *)"cuts"; static const xmlChar * cutStr = (const xmlChar *)"cut"; static const xmlChar * modelStr = (const xmlChar *)"model"; static const xmlChar * parlistStr = (const xmlChar *)"parameters"; static const xmlChar * parStr = (const xmlChar *)"parameter"; static const xmlChar * stateStr = (const xmlChar *)"state"; static const xmlChar * fstateStr = (const xmlChar *)"finalState"; static const xmlChar * errorPlusStr = (const xmlChar *)"errorPlus"; static const xmlChar * errorMinusStr = (const xmlChar *)"errorMinus"; static const xmlChar * cutsetidStr = (const xmlChar *)"cutset_id"; static const xmlChar * beamStr[2] = {(const xmlChar *)"beam1", (const xmlChar *)"beam2"}; static int prepare_hepml_header_libxml2_static (const xmlNodePtr desc); static xmlNodePtr mdlparlist = NULL; static xmlNodePtr sublist = NULL; static xmlNodePtr cutlist = NULL; static xmlDocPtr parse_doc (char fname[]) { xmlDocPtr doc = NULL; xmlParserCtxtPtr parser = xmlNewParserCtxt (); if (NULL == parser) { fprintf (stderr, "mix: (error) failed to allocate libxml2 parser for %s\n", fname); } else { doc = xmlCtxtReadFile (parser, fname, NULL, XML_PARSE_PEDANTIC); xmlFreeParserCtxt (parser); } return doc; } static int get_son_number (xmlNodePtr parent, const xmlChar * name) { int num = 0; xmlNodePtr son = parent->children; while (son) { if (!xmlStrcmp(son->name, name)) { ++num; } son = son->next; } return num; } static xmlNodePtr get_first_son (xmlNodePtr parent, const xmlChar * name) { if (!parent) return NULL; xmlNodePtr son = parent->children; while (son) { if (!xmlStrcmp (son->name, name)) { return xmlCopyNode(son, 1); } son = son->next; } return NULL; } static xmlNodePtr get_first_grandson (xmlNodePtr parent, const xmlChar * sonname, const xmlChar * grandsonname) { if (!parent) return NULL; xmlNodePtr son = parent->children; while (son) { if (!xmlStrcmp (son->name, sonname)) { xmlNodePtr grandson = son->children; while (grandson) { if (!xmlStrcmp (grandson->name, grandsonname)) { return xmlCopyNode(grandson, 1); } grandson = grandson->next; } } son = son->next; } return NULL; } static int modelMerger (const xmlNodePtr pars) { xmlNodePtr son = NULL; xmlNodePtr mdldiff = xmlNewNode (NULL, (const xmlChar *)"model_difference"); if (!pars) return -1; if (!mdlparlist) { mdlparlist = xmlCopyNode (pars, 1); return 0; } son = pars->children; while (son) { if (!xmlStrcmp(son->name, parStr)) { xmlNodePtr t1 = xmlCopyNode (get_first_son (son, nameStr), 1); xmlNodePtr t2 = xmlCopyNode (get_first_son (son, valueStr), 1); if (t1 && t2) { int unused_par = 1; const xmlChar * name = xmlNodeGetContent (t1); const xmlChar * valu = xmlNodeGetContent (t2); xmlNodePtr tmpson = mdlparlist->children; while (tmpson) { if (!xmlStrcmp(tmpson->name, parStr)) { xmlNodePtr t3 = xmlCopyNode (get_first_son (tmpson, nameStr), 1); xmlNodePtr t4 = xmlCopyNode (get_first_son (tmpson, valueStr), 1); if (t1 && t2) { const xmlChar * tmpname = xmlNodeGetContent (t3); const xmlChar * tmpvalu = xmlNodeGetContent (t4); if (!strcmp((char *)name, (char *)tmpname)) { if (!strcmp((char *)valu, (char *)tmpvalu)) { unused_par = 0; break; } } } } tmpson = tmpson->next; } if (unused_par) { if (!xmlAddChild (mdldiff, son)) return -2; } } } son = son->next; } son = mdldiff->children; while (son) { if (!xmlAddChild (mdlparlist, son)) return -3; son = son->next; } return 0; } static int curnum = 0; static int xml_add_subprocess (const xmlNodePtr subprocesses, const xmlNodePtr cuts) { if (!subprocesses || !cuts) return -1; if (!sublist) { sublist = xmlNewNode (NULL, (const xmlChar *)"internal_subprocesses"); curnum = 0; } if (!cutlist) { cutlist = xmlNewNode (NULL, (const xmlChar *)"internal_cuts"); } if (!sublist || !cutlist) return -2; ////////////////////////////////////////////////////////////////////////////////////////////////// { char numStr[8]; xmlNodePtr son = NULL; int subnum = get_son_number (subprocesses, subprocStr); int cutnum = get_son_number (cuts, cutSetStr); if (1 != subnum || 1 != cutnum) return -3; son = subprocesses->children; while (son) { if (!xmlStrcmp (son->name, subprocStr)) { xmlChar * numstr = xmlGetProp (son, cutsetidStr); if (numstr) { int n; if (1 == sscanf ((char *)numstr, "%i", &n)) { sprintf (numStr, "%i", n + curnum); xmlSetProp (son, cutsetidStr, (const xmlChar *)numStr); if (!xmlAddChild (sublist, son)) return -4; ++curnum; } } } son = son->next; } son = cuts->children; while (son) { if (!xmlStrcmp (son->name, cutSetStr)) { if (xmlGetProp (son, cutsetidStr)) { xmlSetProp (son, cutsetidStr, (const xmlChar *)numStr); if (!xmlAddChild (cutlist, son)) return -5; } else { return -6; } } son = son->next; } } return 0; } static long formXMLdocument (const char fname[], const char xml[]) { long pos; char buff[2048]; char * event = NULL; FILE * source = fopen (fname, "r"); FILE * target = fopen (xml, "w"); if (!source || !target) return -1; fgets (buff, 2048, source); if (!strstr (buff, "")) return -2; while (1) { pos = ftell (source); fgets (buff, 2048, source); char * tmp = strstr (buff, "
"); if (tmp) { break; } } fseek (source, pos, SEEK_SET); while (1) { char c1 = fgetc(source); if (c1 == '<') { char c2 = fgetc(source); if (c2 == '?') { fgets (buff, 4, source); if (!strcmp (buff, "xml")) { pos = ftell (source); fseek (source, pos - 5, SEEK_SET); break; } else { pos = ftell (source); fseek (source, pos - 4, SEEK_SET); } } else { pos = ftell (source); fseek (source, pos - 1, SEEK_SET); } } if (c1 == EOF) return -3; } while (1) { pos = ftell (source); fgets (buff, 2048, source); char * tmp = strstr (buff, ""); if (tmp) { fputs (tmp, target); break; } fputs (buff, target); } while (!event) { pos = ftell (source); fgets (buff, 2048, source); if (feof (source)) return -4; event = strstr (buff, ""); } fclose (target); fclose (source); return pos; } int formXMLtree (const char fname[], int procnum) { char * xml = malloc ((strlen(fname) + 5) * sizeof (char)); int n; if (procnum > MAX_FILE_EVENT) { fprintf (stderr, "mix: (error) too many event files! Increase MAX_FILE_EVENT in src/num/include/lhef_routines.h!\n"); exit (-1); } sprintf (xml, "%s.xml", fname); n = formXMLdocument (fname, xml); switch (n) { case -1: fprintf (stderr, "lhe module (warning): can not open file %s or %s\n", fname, xml); goto error; case -2: fprintf (stderr, "lhe module (warning): file %s is not LesHouchesEvents file\n", fname); goto error; case -3: fprintf (stderr, "lhe module (warning): no XML block in file %s\n", fname); goto error; case -4: fprintf (stderr, "lhe module (warning): no events in file %s\n", fname); goto error; } nposition[procnum] = n; xmlDocPtr doc = parse_doc (xml); if (!doc) { fprintf (stderr, "lhe module (error): failed to parse XML block in %s\n", xml); goto error; } { xmlNodePtr rnode = xmlDocGetRootElement (doc); xmlNodePtr xml_proc = xmlCopyNode (get_first_grandson (rnode, descriptionStr, processStr), 1); xmlNodePtr xml_list = xmlCopyNode (get_first_son (xml_proc, subproclistStr), 1); xmlNodePtr xml_fstate = xmlCopyNode (get_first_grandson (xml_proc, fstateStr, stateStr), 1); xmlNodePtr xml_subprc = xmlCopyNode (get_first_grandson (xml_proc, subproclistStr, subprocStr), 1); xmlNodePtr xml_sbname = xmlCopyNode (get_first_son (xml_subprc, symbStr), 1); xmlNodePtr xml_cuts = xmlCopyNode (get_first_grandson (rnode, descriptionStr, cutlistStr), 1); xmlNodePtr xml_files = xmlCopyNode (get_first_son (rnode, filelistStr), 1); xmlNodePtr xml_model = xmlCopyNode (get_first_grandson (rnode, descriptionStr, modelStr), 1); xmlNodePtr xml_pars = xmlCopyNode (get_first_son (xml_model, parlistStr), 1); xmlNodePtr xml_event = xmlCopyNode (get_first_grandson (xml_files, fileStr, (const xmlChar *)"eventsNumber"), 1); xmlNodePtr xml_crosc = xmlCopyNode (get_first_grandson (xml_files, fileStr, (const xmlChar *)"crossSection"), 1); if (fill_base_hepml) { xmlNodePtr xml_tmp = xmlCopyNode (get_first_son (rnode, descriptionStr), 1); prepare_hepml_header_libxml2_static (xml_tmp); fill_base_hepml = 0; } if (!xml_list || !xml_cuts || !xml_event || !xml_crosc || !xml_pars) { fprintf (stderr, "mix: (error) failed to find tags \"subrocesses\", \"cuts\", \"files\" in %s. Remove the file\n", xml); goto error; } if (1 != sscanf ((char *)xmlNodeGetContent (xml_event), "%i", &(nevents[procnum]))) { nevents[procnum] = -1; } if (1 != sscanf ((char *)xmlNodeGetContent (xml_crosc), "%le", &(cs[procnum]))) { cs[procnum] = -1.0; } if (1 != sscanf ((char *)xmlGetProp (xml_crosc, errorPlusStr), "%le", &(cserr[procnum]))) { cserr[procnum] = -1.0; } if (xml_fstate) { strcpy (final_state_name, (char *)xmlNodeGetContent (xml_fstate)); } if (xml_sbname) { strcpy (subproc_name, (char *)xmlNodeGetContent (xml_sbname)); } xml_add_subprocess (xml_list, xml_cuts); modelMerger (xml_pars); } xmlFreeDoc (doc); unlink (xml); free (xml); return 0; error: free (xml); return -1; } static int prepare_hepml_header_libxml2_static (const xmlNodePtr desc) { int err = 0; void * hepml_header = init_lhaef_document (); xmlNodePtr xml_notation_plain; xmlNodePtr xml_notation_latex; //////////////////////////////////////////////////////////////////// lhaef_file lhafile; lhafile.nevents = 0; lhafile.size = 0; lhafile.cross_section = 0.0; lhafile.cross_section_upper_error = 0.0; lhafile.cross_section_lower_error = 0.0; strcpy (lhafile.cross_section_unit, "pb"); strcpy (lhafile.check_sum, "00000000000000000000000000000000"); // 32-bit md5 code!!!!! strcpy (lhafile.check_sum_type, "md5"); err = set_file_description (hepml_header, &lhafile); //////////////////////////////////////////////////////////////////// { lhaef_general_description gendesc; lhapdf_experiment exp; xmlNodePtr xml_title = xmlCopyNode (get_first_son (desc, (const xmlChar *)"title"), 1); xmlNodePtr xml_abstruct = xmlCopyNode (get_first_son (desc, (const xmlChar *)"abstract"), 1); xmlNodePtr xml_comments = xmlCopyNode (get_first_son (desc, (const xmlChar *)"authorComments"), 1); xmlNodePtr xml_ExpGroup = xmlCopyNode (get_first_son (desc, (const xmlChar *)"experimentGroup"), 1); xmlNodePtr xml_ExpGroup_exp = xmlCopyNode (get_first_son (xml_ExpGroup, (const xmlChar *)"experiment"), 1); xmlNodePtr xml_ExpGroup_group = xmlCopyNode (get_first_son (xml_ExpGroup, (const xmlChar *)"group"), 1); xmlNodePtr xml_ExpGroup_person = xmlCopyNode (get_first_son (xml_ExpGroup, (const xmlChar *)"responsiblePerson"), 1); xmlNodePtr xml_ExpGroup_desc = xmlCopyNode (get_first_son (xml_ExpGroup, descriptionStr), 1); gendesc.title[0] = 0; gendesc.abstruct[0] = 0; gendesc.comments[0] = 0; exp.experiment[0] = 0; exp.group[0] = 0; exp.responsiblePerson[0] = 0; exp.description[0] = 0; if (xml_title) strcpy (gendesc.title, xmlNodeGetContent (xml_title)); if (xml_abstruct) strcpy (gendesc.abstruct, xmlNodeGetContent (xml_abstruct)); if (xml_comments) strcpy (gendesc.comments, xmlNodeGetContent (xml_comments)); if (xml_ExpGroup_exp) strcpy (exp.experiment, xmlNodeGetContent (xml_ExpGroup_exp)); if (xml_ExpGroup_group) strcpy (exp.group, xmlNodeGetContent (xml_ExpGroup_group)); if (xml_ExpGroup_person) strcpy (exp.responsiblePerson, xmlNodeGetContent (xml_ExpGroup_person)); if (xml_ExpGroup_desc) strcpy (exp.description, xmlNodeGetContent (xml_ExpGroup_desc)); gendesc.experiment = &exp; err *= set_general_description (hepml_header, &gendesc); } //////////////////////////////////////////////////////////////////// { lhaef_generator gen; xmlNodePtr xml_gen = xmlCopyNode (get_first_son (desc, (const xmlChar *)"generator"), 1); xmlNodePtr xml_gen_name = xmlCopyNode (get_first_son (xml_gen, nameStr), 1); xmlNodePtr xml_gen_version = xmlCopyNode (get_first_son (xml_gen, (const xmlChar *)"version"), 1); xmlNodePtr xml_gen_homepage = xmlCopyNode (get_first_son (xml_gen, (const xmlChar *)"homepage"), 1); xmlNodePtr xml_gen_desc = xmlCopyNode (get_first_son (xml_gen, descriptionStr), 1); gen.name[0] = 0; the_version[0] = 0; gen.version[0] = 0; gen.homepage[0] = 0; gen.description[0] = 0; if (xml_gen_name) strcpy (gen.name, xmlNodeGetContent (xml_gen_name)); if (xml_gen_version) strcpy (the_version, xmlNodeGetContent (xml_gen_version)); if (xml_gen_version) strcpy (gen.version, the_version); if (xml_gen_homepage) strcpy (gen.homepage, xmlNodeGetContent (xml_gen_homepage)); if (xml_gen_desc) { xmlChar * text = xmlNodeGetContent (xml_gen_desc); strcpy (gen.description, text); } err *= set_generator (hepml_header, &gen); } //////////////////////////////////////////////////////////////////// { xmlNodePtr xml_model = xmlCopyNode (get_first_son (desc, modelStr), 1); xmlNodePtr xml_model_name = xmlCopyNode (get_first_son (xml_model, nameStr), 1); xmlNodePtr xml_model_desc = xmlCopyNode (get_first_son (xml_model, descriptionStr), 1); lhaef_model model; model.name[0] = 0; model.description[0] = 0; if (xml_model_name) strcpy (model.name, xmlNodeGetContent (xml_model_name)); if (xml_model_desc) strcpy (model.description, xmlNodeGetContent (xml_model_desc)); err *= set_model (hepml_header, &model); } //////////////////////////////////////////////////////////////////// { xmlNodePtr xml_authors = xmlCopyNode (get_first_son (desc, (const xmlChar *)"authors"), 1); xmlNodePtr son = xml_authors->children; err = set_author_record (hepml_header); while (son) { if (!xmlStrcmp (son->name, (const xmlChar *)"author")) { lhaef_author author; xmlNodePtr xml_author_fname = xmlCopyNode (get_first_son (son, (const xmlChar *)"firstName"), 1); xmlNodePtr xml_author_lname = xmlCopyNode (get_first_son (son, (const xmlChar *)"lastName"), 1); xmlNodePtr xml_author_email = xmlCopyNode (get_first_son (son, (const xmlChar *)"email"), 1); xmlNodePtr xml_author_exprm = xmlCopyNode (get_first_son (son, (const xmlChar *)"experiment"), 1); xmlNodePtr xml_author_group = xmlCopyNode (get_first_son (son, (const xmlChar *)"group"), 1); xmlNodePtr xml_author_organ = xmlCopyNode (get_first_son (son, (const xmlChar *)"organization"), 1); author.firstName[0] = 0; author.lastName[0] = 0; author.email[0] = 0; author.experiment[0] = 0; author.group[0] = 0; author.organization[0] = 0; if (xml_author_fname) strcpy (author.firstName, xmlNodeGetContent (xml_author_fname)); if (xml_author_lname) strcpy (author.lastName, xmlNodeGetContent (xml_author_lname)); if (xml_author_email) strcpy (author.email, xmlNodeGetContent (xml_author_email)); if (xml_author_exprm) strcpy (author.experiment, xmlNodeGetContent (xml_author_exprm)); if (xml_author_group) strcpy (author.group, xmlNodeGetContent (xml_author_group)); if (xml_author_organ) strcpy (author.organization, xmlNodeGetContent (xml_author_organ)); err = add_author(hepml_header, &author); } son = son->next; } } //////////////////////////////////////////////////////////////////// { lhaef_process proc; lhaef_math_notation fs_notation; xmlNodePtr xml_process = xmlCopyNode (get_first_son (desc, processStr), 1); xmlNodePtr xml_cs = xmlCopyNode (get_first_son (xml_process, (const xmlChar *)"crossSection"), 1); xmlNodePtr xml_final = xmlCopyNode (get_first_son (xml_process, (const xmlChar *)"finalState"), 1); xmlNodePtr xml_final_state = xmlCopyNode (get_first_son (xml_final, (const xmlChar *)"state"), 1); xml_notation_plain = xmlCopyNode (get_first_grandson (xml_final, symbStr, plainStr), 1); xml_notation_latex = xmlCopyNode (get_first_grandson (xml_final, symbStr, latexStr), 1); proc.final_state[0] = 0; fs_notation.plain[0] = 0; fs_notation.latex[0] = 0; if (xml_final_state) strcpy (proc.final_state, xmlNodeGetContent (xml_final_state)); if (xml_notation_plain) strcpy (fs_notation.plain, xmlNodeGetContent (xml_notation_plain)); if (xml_notation_latex) strcpy (fs_notation.latex, xmlNodeGetContent (xml_notation_latex)); proc.final_state_notation = &fs_notation; strcpy (proc.cross_section_unit, "pb"); if (xml_cs) { xmlChar * prop1 = xmlGetProp (xml_cs, errorPlusStr); xmlChar * prop2 = xmlGetProp (xml_cs, errorMinusStr); if (prop1) { if (1 != sscanf (prop1, "%le", &(proc.cross_section_upper_error))) { proc.cross_section_upper_error = -1.0; } } if (prop2) { if (1 != sscanf (prop2, "%le", &(proc.cross_section_lower_error))) { proc.cross_section_lower_error = -1.0; } } if (1 != sscanf (xmlNodeGetContent (xml_cs), "%le", &(proc.cross_section))) { proc.cross_section = 0; } } err *= create_process(hepml_header, &proc); } //////////////////////////////////////////////////////////////////// { int i; for (i = 0; i < 2; ++i) { lhaef_beam beam; lhaef_pdf pdf; lhaef_alphas alphas; xmlNodePtr xml_process = xmlCopyNode (get_first_son (desc, processStr), 1); xmlNodePtr xml_beam1 = xmlCopyNode (get_first_son (xml_process, beamStr[i]), 1); xmlNodePtr xml_part = xmlCopyNode (get_first_son (xml_beam1, (const xmlChar *)"particle"), 1); xmlNodePtr xml_energy = xmlCopyNode (get_first_son (xml_beam1, (const xmlChar *)"energy"), 1); xmlNodePtr xml_pdf = xmlCopyNode (get_first_son (xml_beam1, (const xmlChar *)"pdf"), 1); xmlNodePtr xml_qcd = xmlCopyNode (get_first_son (xml_beam1, (const xmlChar *)"QCDCoupling"), 1); xmlNodePtr xml_qcd_lambda = xmlCopyNode (get_first_son (xml_qcd, (const xmlChar *)"Lambda"), 1); xmlNodePtr xml_qcd_nflv = xmlCopyNode (get_first_son (xml_qcd, (const xmlChar *)"NFlavours"), 1); xmlNodePtr xml_qcd_nloops = xmlCopyNode (get_first_son (xml_qcd, (const xmlChar *)"NLoopsAlphaS"), 1); if (xml_part) strcpy (beam.particle_name, xmlNodeGetContent (xml_part)); if (xml_part) { if (1 != sscanf (xmlGetProp (xml_part, (const xmlChar *)"pdgcode"), "%i", &(beam.particle_pdgcode))) beam.particle_pdgcode = 0; } if (xml_energy) { if (1 != sscanf (xmlNodeGetContent (xml_energy), "%lf", &(beam.energy))) beam.energy = 0; } strcpy (beam.energy_unit, "GeV"); the_pbeam[i] = beam.particle_pdgcode; the_ebeam[i] = beam.energy; strcpy (alphas.lambda_unit, "GeV"); alphas.description[0] = 0; if (xml_qcd_nloops) { if (1 != sscanf (xmlNodeGetContent (xml_qcd_nloops), "%i", &(alphas.nloops))) alphas.nloops = 0; } if (xml_qcd_nflv) { if (1 != sscanf (xmlNodeGetContent (xml_qcd_nflv), "%i", &(alphas.nflavours))) alphas.nflavours = 0; } if (xml_qcd_lambda) { if (1 != sscanf (xmlNodeGetContent (xml_qcd_lambda), "%lf", &(alphas.lambda))) alphas.lambda = 0; } pdf.name[0] = 0; pdf.version[0] = 0; pdf.lhapdf_filename[0] = 0; pdf.pdflib_set = -1; pdf.pdflib_group = -1; pdf.lhapdf_set = -1; pdf.lhapdf_member = -1; if (2212 == abs(beam.particle_pdgcode)) { xmlChar * prop1 = xmlGetProp (xml_pdf, nameStr); xmlChar * prop2 = xmlGetProp (xml_pdf, (const xmlChar *)"version"); xmlChar * prop3 = xmlGetProp (xml_pdf, (const xmlChar *)"PDFLIBset"); xmlChar * prop4 = xmlGetProp (xml_pdf, (const xmlChar *)"PDFLIBgroup"); xmlChar * prop5 = xmlGetProp (xml_pdf, (const xmlChar *)"LHAPDFset"); xmlChar * prop6 = xmlGetProp (xml_pdf, (const xmlChar *)"LHAPDFmember"); pdf.name[0] = 0; pdf.version[0] = 0; if (prop1) strcpy (pdf.name, prop1); if (prop2) strcpy (pdf.version, prop2); if (prop3) if (1 != sscanf (prop3, "%i", &(pdf.pdflib_set))) pdf.pdflib_set = -1; if (prop4) if (1 != sscanf (prop4, "%i", &(pdf.pdflib_group))) pdf.pdflib_group = -1; if (prop5) if (1 != sscanf (prop5, "%i", &(pdf.lhapdf_set))) pdf.lhapdf_set = -1; if (prop6) if (1 != sscanf (prop6, "%i", &(pdf.lhapdf_member))) pdf.lhapdf_member = -1; err *= add_process_beam (hepml_header, i, &beam); err *= add_process_beam_pdf (hepml_header, i, &pdf); err *= add_process_beam_pdf_alphas (hepml_header, &alphas); } else { err *= add_process_beam (hepml_header, i, &beam); err *= add_process_alphas (hepml_header, &alphas); } the_PDFLIBgroup[i] = pdf.pdflib_group; the_PDFLIBset[i] = pdf.pdflib_set; } } return err; } char * prepare_hepml_header_libxml2_dynamic (void) { int err = 0; void * hepml_header = init_lhaef_document (); //////////////////////////////////////////////////////////////////// xmlNodePtr son = mdlparlist->children; while (son) { if (!xmlStrcmp (son->name, parStr)) { lhaef_parameter par; lhaef_math_notation not; xmlNodePtr xml_model_par_name = xmlCopyNode (get_first_son (son, nameStr), 1); xmlNodePtr xml_model_par_valu = xmlCopyNode (get_first_son (son, valueStr), 1); xmlNodePtr xml_model_par_desc = xmlCopyNode (get_first_son (son, descriptionStr), 1); xmlNodePtr xml_notation_plain = xmlCopyNode (get_first_grandson (son, symbStr, plainStr), 1); xmlNodePtr xml_notation_latex = xmlCopyNode (get_first_grandson (son, symbStr, latexStr), 1); par.name[0] = 0; par.value[0] = 0; par.description[0] = 0; not.plain[0] = 0; not.latex[0] = 0; if (xml_model_par_name) strcpy (par.name, xmlNodeGetContent (xml_model_par_name)); if (xml_model_par_valu) strcpy (par.value, xmlNodeGetContent (xml_model_par_valu)); if (xml_model_par_desc) strcpy (par.description, xmlNodeGetContent (xml_model_par_desc)); if (xml_notation_plain) strcpy (not.plain, xmlNodeGetContent (xml_notation_plain)); if (xml_notation_latex) strcpy (not.latex, xmlNodeGetContent (xml_notation_latex)); par.notation = ¬ err = add_model_parameter (hepml_header, &par); } son = son->next; } //////////////////////////////////////////////////////////////////// son = cutlist->children; while (son) { if (!xmlStrcmp (son->name, (const xmlChar *)"cutSet")) { int cutsetid = 0; xmlNodePtr grandson = son->children; xmlChar * prop = xmlGetProp (son, cutsetidStr); if (NULL != prop) { if (1 != sscanf (prop, "%i", &cutsetid)) { cutsetid = 0; } } err = add_cutset (hepml_header, cutsetid); while (grandson) { if (!xmlStrcmp (grandson->name, cutStr)) { int minon = 0; int maxon = 0; lhaef_cut cut; lhaef_math_notation not; xmlNodePtr xml_cut_object = xmlCopyNode (get_first_son (grandson, (const xmlChar *)"object"), 1); xmlNodePtr xml_cut_min = xmlCopyNode (get_first_son (grandson, (const xmlChar *)"minValue"), 1); xmlNodePtr xml_cut_max = xmlCopyNode (get_first_son (grandson, (const xmlChar *)"maxValue"), 1); xmlNodePtr xml_cut_logic = xmlCopyNode (get_first_son (grandson, (const xmlChar *)"logic"), 1); xmlNodePtr xml_cut_object_name = xmlCopyNode (get_first_son (xml_cut_object, nameStr), 1); xmlNodePtr xml_notation_plain = xmlCopyNode (get_first_grandson (xml_cut_object, symbStr, plainStr), 1); xmlNodePtr xml_notation_latex = xmlCopyNode (get_first_grandson (xml_cut_object, symbStr, latexStr), 1); cut.name[0] = 0; cut.cut_logic[0] = 0; not.plain[0] = 0; not.latex[0] = 0; if (xml_cut_object_name) { strcpy (cut.name, xmlNodeGetContent (xml_cut_object_name)); } if (xml_cut_min) { minon = 1; if (1 != sscanf (xmlNodeGetContent (xml_cut_min), "%lf", &(cut.min_value))) { cut.min_value = 0; } } if (xml_cut_max) { maxon = 1; if (1 != sscanf (xmlNodeGetContent (xml_cut_max), "%lf", &(cut.max_value))) { cut.max_value = 0; } } if (xml_cut_logic) strcpy (cut.cut_logic, xmlNodeGetContent (xml_cut_logic)); if (xml_notation_plain) strcpy (not.plain, xmlNodeGetContent (xml_notation_plain)); if (xml_notation_latex) strcpy (not.latex, xmlNodeGetContent (xml_notation_latex)); cut.notation = ¬ err = add_cut (hepml_header, &cut, minon, maxon); } grandson = grandson->next; } } son = son->next; } //////////////////////////////////////////////////////////////////// son = sublist->children; while (son) { int the_num; if (!xmlStrcmp (son->name, subprocStr)) { lhaef_subprocess subproc; lhaef_math_notation scale_notation; if (1 != sscanf (xmlGetProp (son, cutsetidStr), "%i", &(the_num))) { the_num = 0; } xmlNodePtr xml_sub_name = xmlCopyNode (get_first_son (son, symbStr), 1); xmlNodePtr xml_sub_cs = xmlCopyNode (get_first_son (son, (const xmlChar *)"crossSection"), 1); xmlNodePtr xml_sub_fscale = xmlCopyNode (get_first_son (son, (const xmlChar *)"FactorisationScale"), 1); xmlNodePtr xml_sub_rscale = xmlCopyNode (get_first_son (son, (const xmlChar *)"RenormalisationScale"), 1); subproc.name[0] = 0; if (xml_sub_name) strcpy (subproc.name, xmlNodeGetContent (xml_sub_name)); if (1 != sscanf (xmlNodeGetContent (xml_sub_cs), "%le", &(subproc.cross_section))) { subproc.cross_section = 0; } strcpy (subproc.cross_section_unit, "pb"); if (1 != sscanf (xmlGetProp (xml_sub_cs, errorPlusStr), "%le", &(subproc.cross_section_upper_error))) { subproc.cross_section_upper_error = -1.0; } if (1 != sscanf (xmlGetProp (xml_sub_cs, errorMinusStr), "%le", &(subproc.cross_section_lower_error))) { subproc.cross_section_lower_error = -1.0; } scale_notation.plain[0] = 0; scale_notation.latex[0] = 0; xmlNodePtr xml_notation_plain = xmlCopyNode (get_first_son (xml_sub_fscale, plainStr), 1); xmlNodePtr xml_notation_latex = xmlCopyNode (get_first_son (xml_sub_fscale, latexStr), 1); if (xml_notation_plain) strcpy (scale_notation.plain, xmlNodeGetContent (xml_notation_plain)); if (xml_notation_latex) strcpy (scale_notation.latex, xmlNodeGetContent (xml_notation_latex)); subproc.FactorisationScale = &scale_notation; scale_notation.plain[0] = 0; scale_notation.latex[0] = 0; xmlNodePtr xml_notation_plain2 = xmlCopyNode (get_first_son (xml_sub_rscale, plainStr), 1); xmlNodePtr xml_notation_latex2 = xmlCopyNode (get_first_son (xml_sub_rscale, latexStr), 1); if (xml_notation_plain2) strcpy (scale_notation.plain, xmlNodeGetContent (xml_notation_plain2)); if (xml_notation_latex2) strcpy (scale_notation.latex, xmlNodeGetContent (xml_notation_latex2)); subproc.RenormalisationScale = &scale_notation; err = add_subprocess (hepml_header, &subproc, the_num); } son = son->next; } return form_hepml_document (hepml_header); } static char * prepare_file_header_libxml2_dynamic (void) { char * filestr = malloc ((512 + strlen (get_file_description ())) * sizeof (char)); strcpy (filestr, "\n"); strcat (filestr, "\n"); strcat (filestr, " \n"); strcat (filestr, " \n"); strcat (filestr, get_file_description ()); strcat (filestr, " \n"); strcat (filestr, " \n"); return filestr; } int write_file_header_libxml2 (const char fname[], const char mode[]) { FILE * outFile = fopen (fname, mode); if (!outFile) { return 0; } fprintf (outFile, "\n"); fprintf (outFile, "\n", the_version); fprintf (outFile, "\n"); fprintf (outFile, "
\n"); fprintf (outFile, "%s", prepare_file_header_libxml2_dynamic ()); fclose (outFile); return 0; } #endif int testEvent (FILE * source, char fname[], long pos) { int i; int go = 1; char buff[4096]; int nup, idproc, id, stat; int moth1, moth2, color1, color2; double x, y, z, e, m, time, spin; double xwgt, aqed, aqcd, scale; fseek (source, pos, SEEK_SET); if (!fgets (buff, 4096, source)) { if (feof (source)) return 1; fprintf (stderr, "mix: (error) %li - wrong position for LesHouches event in %s (no start-tag)\n", pos, fname); return -1; } if (!strcmp ("", buff)) { fprintf (stderr, "mix: (error) %li - wrong position for LesHouches event in %s (no start-tag)\n", pos, fname); return -2; } fgets (buff, 4096, source); if (feof (source)) goto enderror; if (6 != sscanf (buff, "%i %i %lf %le %le %le", &nup, &idproc, &xwgt, &scale, &aqed, &aqcd)) { fprintf (stderr, "mix: (error) wrong LesHouches event format in %s \n", fname); return -3; } for (i = 0; i < nup; ++i) { fgets (buff, 4096, source); if (feof (source)) goto enderror; if (13 != sscanf (buff, "%i %i %i %i %i %i %le %le %le %le %le %le %le", &id, &stat, &moth1, &moth2, &color1, &color2, &x, &y, &z, &e, &m, &time, &spin)) { fprintf (stderr, "mix: (error) wrong LesHouches event format in %s \n", fname); return -4; } } while (go) { fgets (buff, 4096, source); if (feof (source)) goto enderror; if ('#' != buff[0]) go = 0; } if (!strcmp ("", buff)) { fprintf (stderr, "mix: (error) no end-tag and no #-comment in %s\n", fname); return -5; } return 0; enderror: fprintf (stderr, "mix: (error) unexpected end of LHE event file %s \n", fname); return -6; } int moveEvent (int num, char fname[], FILE * source, long spos, FILE * target, long tpos) { int i; int go = 1; char buff[4096]; int nup, idprup; double xwgtup, aqedup, aqcdup, scaleup; fseek (source, spos, SEEK_SET); fseek (target, tpos, SEEK_SET); if (!fgets (buff, 4096, source)) { if (feof (source)) return 1; fprintf (stderr, "mix: (error) %li - wrong position for LesHouches event in %s (no start-tag)\n", spos, fname); return -1; } if (!strcmp ("", buff)) { fprintf (stderr, "mix: (error) %li - wrong position for LesHouches event in %s (no start-tag)\n", spos, fname); return -2; } fputs (buff, target); fgets (buff, 4096, source); if (feof (source)) goto enderror; if (6 != sscanf (buff, "%i %i %le %le %le %le", &nup, &idprup, &xwgtup, &scaleup, &aqedup, &aqcdup)) { fprintf (stderr, "mix: (error) wrong LesHouches event format in %s \n", fname); return -4; } fprintf (target, "%i %i %17.10E %17.10E %17.10E %17.10E\n", nup, num, xwgtup, scaleup, aqedup, aqcdup); for (i = 0; i < nup; ++i) { fgets (buff, 4096, source); if (feof (source)) goto enderror; fputs (buff, target); } while (go) { fgets (buff, 4096, source); if (feof (source)) goto enderror; if ('#' != buff[0]) { go = 0; } else { fputs (buff, target); } } if (!strcmp ("", buff)) { fprintf (stderr, "mix: (error) no end-tag in %s\n", fname); return -4; } fputs (buff, target); return 0; enderror: fprintf (stderr, "mix: (error) unexpected end of LHE event file %s \n", fname); return -6; } int analyzeLHEfile (const char fname[], int i) { long pos; int err; double err1, err2, thecs; char buff[2048]; char * event = NULL; FILE * source = fopen (fname, "r"); char * tmp; if (!source) return -1; fgets (buff, 2048, source); if (!strstr (buff, "")) return -2; cs[i] = -1.; cserr[i] = -1.; nevents[i] = -1; while (1) { pos = ftell (source); fgets (buff, 2048, source); if (strstr (buff, ""); len = strlen(ver) - strlen (ttt); strncpy (the_version, ver, len); the_version[len] = 0; } tmp = strstr (buff, "")) { break; } } if (tmp) { err = sscanf (buff, " %le", &err1, &err2, &thecs); if (3 == err) { cs[i] = thecs; cserr[i] = err1; } } rewind (source); while (1) { pos = ftell (source); fgets (buff, 2048, source); tmp = strstr (buff, ""); if (tmp || strstr (buff, "")) { break; } } if (tmp) { int nevnt; err = sscanf (buff, " %d", &nevnt); if (1 == err) { nevents[i] = nevnt; } } fseek (source, pos, SEEK_SET); while (!event) { fgets (buff, 2048, source); if (feof (source)) { fclose (source); return -4; } event = strstr (buff, ""); } fgets (buff, 1024, source); if (1) { int i1, i2, i3, i4, i5, i6; double d1, d2; err = sscanf (buff, "%d %d %le %le %d %d %d %d 3 1", &i1, &i2, &d1, &d2, &i3, &i4, &i5, &i6); if (8 == err) { the_pbeam[0] = i1; the_pbeam[1] = i2; the_ebeam[0] = d1; the_ebeam[1] = d2; the_PDFLIBgroup[0] = i3; the_PDFLIBgroup[1] = i4; the_PDFLIBset[0] = i5; the_PDFLIBset[1] = i6; } } fgets (buff, 1024, source); if (cs[i] < 0.) { int tt; err = sscanf (buff, "%le %le %le %d\n", &thecs, &err1, &err2, &tt); if (4 == err) { cs[i] = thecs; cserr[i] = err1; } } event = NULL; while (!event) { pos = ftell (source); fgets (buff, 2048, source); if (feof (source)) { fclose (source); return -4; } event = strstr (buff, ""); } nposition[i] = pos; if (nevents[i] < 0) { nevents[i] = 0; event = NULL; while (!feof (source)) { fgets (buff, 2048, source); event = strstr (buff, ""); if (event) { ++nevents[i]; } buff[0] = 0; } } fclose (source); return 0; } int analyzeMultiProcLHEfile (const char fname[]) { long pos; int err, tt; double err1, err2, thecs; char buff[2048]; char * event = NULL; FILE * source = fopen (fname, "r"); int numproc = 0; tot_proc_num = 0; if (!source) return -1; fgets (buff, 2048, source); if (!strstr (buff, "")) return -2; while (1) { if (feof (source)) { fclose (source); return -4; } fgets (buff, 2048, source); if (strstr (buff, "")) { break; } } fgets (buff, 1024, source); if (1) { int i1, i2, i3, i4, i5, i6, i7; double d1, d2; err = sscanf (buff, "%d %d %le %le %d %d %d %d 3 %d", &i1, &i2, &d1, &d2, &i3, &i4, &i5, &i6, &i7); if (9 == err) { the_pbeam[0] = i1; the_pbeam[1] = i2; the_ebeam[0] = d1; the_ebeam[1] = d2; the_PDFLIBgroup[0] = i3; the_PDFLIBgroup[1] = i4; the_PDFLIBset[0] = i5; the_PDFLIBset[1] = i6; tot_proc_num = i7; } } fgets (buff, 2048, source); while (numproc < tot_proc_num) { if (feof (source)) { fclose (source); return -5; } if (numproc > MAX_FILE_EVENT) { fclose (source); return -6; } err = sscanf (buff, "%le %le %le %d\n", &thecs, &err1, &err2, &tt); if (4 == err) { cs[numproc] = thecs; cserr[numproc] = err1; ++numproc; } fgets (buff, 2048, source); if (strstr (buff, "")) { break; } } event = NULL; while (!event) { pos = ftell (source); fgets (buff, 2048, source); if (feof (source)) { fclose (source); return -4; } event = strstr (buff, ""); } nposition[0] = pos; fclose (source); return 0; } int setInfoWithoutHEPML (char fname[], FILE * f, int procnum) { int n, i; double xwgt; eventUP evnt; char buff[2048]; char * stop = NULL; while (!stop) { fgets (buff, 2048, f); if (feof (f)) return -4; stop = strstr (buff, ""); } fgets (buff, 2048, f); fgets (buff, 2048, f); if (4 != sscanf (buff, "%le %le %le %d", &cs[procnum], &cserr[procnum], &xwgt, &n)) { cs[procnum] = 0.0; cserr[procnum] = 0.0; } stop = NULL; while (!stop) { nposition[procnum] = ftell (f); fgets (buff, 2048, f); if (feof (f)) return -4; stop = strstr (buff, ""); } if (0 == getLHAevent (fname, f, nposition[procnum], &evnt)) { sprintf (subproc_name, "%s, %s -> ", kfname(evnt.IDpartUP[0]), kfname(evnt.IDpartUP[1])); for (i = 2; i < evnt.NpartUP; ++i) { strcat (subproc_name, kfname(evnt.IDpartUP[i])); if (i < evnt.NpartUP - 1) strcat (subproc_name, ", "); } } return 0; } long getEventPosition (int procnum) { return nposition[procnum]; } char * getFinalStateName (void) { return final_state_name; } char * getSubprocessName (void) { return subproc_name; } int getEventNumber (int procnum) { return nevents[procnum]; } double getCrossSection (int procnum) { return cs[procnum]; } double getCrossSectionErr (int procnum) { return cserr[procnum]; } int getPbeam (int i) { return the_pbeam[i]; } double getEbeam (int i) { return the_ebeam[i]; } int getPDFLIBgroup (int i) { return the_PDFLIBgroup[i]; } int getPDFLIBset (int i) { return the_PDFLIBset[i]; } char * getCHEPversion (void) { return the_version; } int getTotProcNumber (void) { return tot_proc_num; }