1 from __future__ import division
2 import xml.etree.ElementTree as ET
3 import math
4 import os
5 import shutil
6 import logging
7
8 logger = logging.getLogger('madgraph.models')
9
10 try:
11 import madgraph.iolibs.file_writers as file_writers
12 import madgraph.various.misc as misc
13 except:
14 import internal.file_writers as file_writers
15 import internal.misc as misc
18 """ a class for invalid param_card """
19 pass
20
22 """A class for a param_card parameter"""
23
24 - def __init__(self, param=None, block=None, lhacode=None, value=None, comment=None):
25 """Init the parameter"""
26
27 self.format = 'float'
28 if param:
29 block = param.lhablock
30 lhacode = param.lhacode
31 value = param.value
32 comment = param.comment
33 format = param.format
34
35 self.lhablock = block
36 if lhacode:
37 self.lhacode = lhacode
38 else:
39 self.lhacode = []
40 self.value = value
41 self.comment = comment
42
44 """ set the block name """
45
46 self.lhablock = block
47
49 """ initialize the information from a str"""
50
51 if '#' in text:
52 data, self.comment = text.split('#',1)
53 else:
54 data, self.comment = text, ""
55
56
57 data = data.split()
58 if not len(data):
59 return
60 try:
61 self.lhacode = tuple([int(d) for d in data[:-1]])
62 except Exception:
63 self.lhacode = tuple([int(d) for d in data[:-1] if d.isdigit()])
64 self.value= ' '.join(data[len(self.lhacode):])
65 else:
66 self.value = data[-1]
67
68
69 try:
70 self.value = float(self.value)
71 except:
72 self.format = 'str'
73 pass
74 else:
75 if self.lhablock == 'modsel':
76 self.format = 'int'
77 self.value = int(self.value)
78
80 """ initialize the decay information from a str"""
81
82 if '#' in text:
83 data, self.comment = text.split('#',1)
84 else:
85 data, self.comment = text, ""
86
87
88 data = data.split()
89 if not len(data):
90 return
91 self.lhacode = [int(d) for d in data[2:]]
92 self.lhacode.sort()
93 self.lhacode = tuple([len(self.lhacode)] + self.lhacode)
94
95 self.value = float(data[0])
96 self.format = 'decay_table'
97
99 """ return a SLAH string """
100
101 if self.format == 'float':
102 if self.lhablock == 'decay' and not isinstance(self.value,basestring):
103 return 'DECAY %s %e # %s' % (' '.join([str(d) for d in self.lhacode]), self.value, self.comment)
104 elif self.lhablock == 'decay':
105 return 'DECAY %s Auto # %s' % (' '.join([str(d) for d in self.lhacode]), self.comment)
106 elif self.lhablock and self.lhablock.startswith('qnumbers'):
107 return ' %s %i # %s' % (' '.join([str(d) for d in self.lhacode]), int(self.value), self.comment)
108 else:
109 return ' %s %e # %s' % (' '.join([str(d) for d in self.lhacode]), self.value, self.comment)
110 elif self.format == 'int':
111 return ' %s %i # %s' % (' '.join([str(d) for d in self.lhacode]), int(self.value), self.comment)
112 elif self.format == 'str':
113 if self.lhablock == 'decay':
114 return 'DECAY %s Auto # %s' % (' '.join([str(d) for d in self.lhacode]), self.comment)
115 return ' %s %s # %s' % (' '.join([str(d) for d in self.lhacode]), self.value, self.comment)
116 elif self.format == 'decay_table':
117 return ' %e %s # %s' % ( self.value,' '.join([str(d) for d in self.lhacode]), self.comment)
118 elif self.format == 'int':
119 return ' %s %i # %s' % (' '.join([str(d) for d in self.lhacode]), int(self.value), self.comment)
120 else:
121 if self.lhablock == 'decay':
122 return 'DECAY %s %d # %s' % (' '.join([str(d) for d in self.lhacode]), self.value, self.comment)
123 else:
124 return ' %s %d # %s' % (' '.join([str(d) for d in self.lhacode]), self.value, self.comment)
125
128 """ list of parameter """
129
131 if name:
132 self.name = name.lower()
133 else:
134 self.name = name
135 self.scale = None
136 self.comment = ''
137 self.decay_table = {}
138 self.param_dict={}
139 list.__init__(self)
140
141 - def get(self, lhacode, default=None):
142 """return the parameter associate to the lhacode"""
143 if not self.param_dict:
144 self.create_param_dict()
145
146 if isinstance(lhacode, int):
147 lhacode = (lhacode,)
148
149 try:
150 return self.param_dict[tuple(lhacode)]
151 except KeyError:
152 if default is None:
153 raise KeyError, 'id %s is not in %s' % (tuple(lhacode), self.name)
154 else:
155 return Parameter(block=self, lhacode=lhacode, value=default,
156 comment='not define')
157
159 """ remove a parameter """
160 list.remove(self, self.get(lhacode))
161
162 return self.param_dict.pop(tuple(lhacode))
163
164 - def __eq__(self, other, prec=1e-4):
165 """ """
166 if len(self) != len(other):
167 return False
168
169 return not any(abs(param.value-other.param_dict[key].value)> prec * abs(param.value)
170 for key, param in self.param_dict.items())
171
172 - def __ne__(self, other, prec=1e-4):
173 return not self.__eq__(other, prec)
174
176
177 assert isinstance(obj, Parameter)
178 if not hasattr(self, 'name'):
179 self.__init__(obj.lhablock)
180 assert not obj.lhablock or obj.lhablock == self.name
181
182
183
184 if not hasattr(self, 'param_dict'):
185 self.param_dict = {}
186
187 if tuple(obj.lhacode) in self.param_dict:
188 if self.param_dict[tuple(obj.lhacode)].value != obj.value:
189 raise InvalidParamCard, '%s %s is already define to %s impossible to assign %s' % \
190 (self.name, obj.lhacode, self.param_dict[tuple(obj.lhacode)].value, obj.value)
191 return
192 list.append(self, obj)
193
194 self.param_dict[tuple(obj.lhacode)] = obj
195
197 """create a link between the lhacode and the Parameter"""
198 for param in self:
199 self.param_dict[tuple(param.lhacode)] = param
200
201 return self.param_dict
202
204 """ """
205 self.scale = scale
206
208 "set inforamtion from the line"
209
210 if '#' in text:
211 data, self.comment = text.split('#',1)
212 else:
213 data, self.commant = text, ""
214
215 data = data.lower()
216 data = data.split()
217 self.name = data[1]
218 if len(data) == 3:
219 if data[2].startswith('q='):
220
221 self.scale = float(data[2][2:])
222 elif self.name == 'qnumbers':
223 self.name += ' %s' % data[2]
224 elif len(data) == 4 and data[2] == 'q=':
225
226 self.scale = float(data[3])
227
228 return self
229
231 """returns the list of id define in this blocks"""
232
233 return [p.lhacode for p in self]
234
236 """ return a str in the SLAH format """
237
238 text = """###################################""" + \
239 """\n## INFORMATION FOR %s""" % self.name.upper() +\
240 """\n###################################\n"""
241
242
243 if self.name == 'decay':
244 for param in self:
245 pid = param.lhacode[0]
246 param.set_block('decay')
247 text += str(param)+ '\n'
248 if self.decay_table.has_key(pid):
249 text += str(self.decay_table[pid])+'\n'
250 return text
251 elif self.name.startswith('decay'):
252 text = ''
253
254 elif not self.scale:
255 text += 'BLOCK %s # %s\n' % (self.name.upper(), self.comment)
256 else:
257 text += 'BLOCK %s Q= %e # %s\n' % (self.name.upper(), self.scale, self.comment)
258
259 text += '\n'.join([str(param) for param in self])
260 return text + '\n'
261
264 """ a param Card: list of Block """
265 mp_prefix = 'MP__'
266
267 header = \
268 """######################################################################\n""" + \
269 """## PARAM_CARD AUTOMATICALY GENERATED BY MG5 ####\n""" + \
270 """######################################################################\n"""
271
272
274 self.order = []
275
276 if isinstance(input_path, ParamCard):
277 self.order = list(input_path.order)
278 self.update(input_path)
279 self.input_path = input_path.input_path
280 else:
281 self.input_path = input_path
282 if input_path:
283 self.read(input_path)
284
285 - def read(self, input_path):
286 """ read a card and full this object with the content of the card """
287
288 if isinstance(input_path, str):
289 input = open(input_path)
290 else:
291 input = input_path
292
293
294 cur_block = None
295 for line in input:
296 line = line.strip()
297 if not line or line[0] == '#':
298 continue
299 line = line.lower()
300 if line.startswith('block'):
301 cur_block = Block()
302 cur_block.load_str(line)
303 self.append(cur_block)
304 continue
305
306 if line.startswith('decay'):
307 if not self.has_block('decay'):
308 cur_block = Block('decay')
309 self.append(cur_block)
310 else:
311 cur_block = self['decay']
312 param = Parameter()
313 param.set_block(cur_block.name)
314 param.load_str(line[6:])
315 cur_block.append(param)
316 continue
317
318 if cur_block is None:
319 continue
320
321 if cur_block.name == 'decay':
322
323 id = cur_block[-1].lhacode[0]
324 cur_block = Block('decay_table_%s' % id)
325 self['decay'].decay_table[id] = cur_block
326
327
328
329
330 if cur_block.name.startswith('decay_table'):
331 param = Parameter()
332 param.load_decay(line)
333 try:
334 cur_block.append(param)
335 except InvalidParamCard:
336 pass
337 else:
338 param = Parameter()
339 param.set_block(cur_block.name)
340 param.load_str(line)
341 cur_block.append(param)
342
343 return self
344
345 - def write(self, outpath):
346 """schedular for writing a card"""
347
348
349 blocks = self.order_block()
350 text = self.header
351 text += ''.join([str(block) for block in blocks])
352
353 if not outpath:
354 return text
355 elif isinstance(outpath, str):
356 file(outpath,'w').write(text)
357 else:
358 outpath.write(text)
359
361 """return a text file allowing to pass from this card to the new one
362 via the set command"""
363
364 diff = ''
365 for blockname, block in self.items():
366 for param in block:
367 lhacode = param.lhacode
368 value = param.value
369 new_value = new_card[blockname].get(lhacode).value
370 if not misc.equal(value, new_value, 6, zero_limit=False):
371 lhacode = ' '.join([str(i) for i in lhacode])
372 diff += 'set param_card %s %s %s # orig: %s\n' % \
373 (blockname, lhacode , new_value, value)
374 return diff
375
376
377
378
379 - def write_inc_file(self, outpath, identpath, default, need_mp=False):
380 """ write a fortran file which hardcode the param value"""
381
382 fout = file_writers.FortranWriter(outpath)
383 defaultcard = ParamCard(default)
384 for line in open(identpath):
385 if line.startswith('c ') or line.startswith('ccccc'):
386 continue
387 split = line.split()
388 if len(split) < 3:
389 continue
390 block = split[0]
391 lhaid = [int(i) for i in split[1:-1]]
392 variable = split[-1]
393 if block in self:
394 try:
395 value = self[block].get(tuple(lhaid)).value
396 except KeyError:
397 value =defaultcard[block].get(tuple(lhaid)).value
398 logger.warning('information about \"%s %s" is missing using default value: %s.' %\
399 (block, lhaid, value))
400
401 else:
402 value =defaultcard[block].get(tuple(lhaid)).value
403 logger.warning('information about \"%s %s" is missing (full block missing) using default value: %s.' %\
404 (block, lhaid, value))
405 value = str(value).lower()
406 fout.writelines(' %s = %s' % (variable, str(value).replace('e','d')))
407 if need_mp:
408 fout.writelines(' mp__%s = %s_16' % (variable, value))
409
411 """add an object to this"""
412
413 assert isinstance(obj, Block)
414 self[obj.name] = obj
415 if not obj.name.startswith('decay_table'):
416 self.order.append(obj)
417
418
419
421 return self.has_key(name)
422
424 """ reorganize the block """
425 return self.order
426
428 """ rename the blocks """
429
430 for old_name, new_name in name_dict.items():
431 self[new_name] = self.pop(old_name)
432 self[new_name].name = new_name
433 for param in self[new_name]:
434 param.lhablock = new_name
435
437 """ remove a blocks """
438 assert len(self[name])==0
439 [self.order.pop(i) for i,b in enumerate(self.order) if b.name == name]
440 self.pop(name)
441
443 """ remove a parameter """
444 if self.has_param(block, lhacode):
445 self[block].remove(lhacode)
446 if len(self[block]) == 0:
447 self.remove_block(block)
448
450 """check if param exists"""
451
452 try:
453 self[block].get(lhacode)
454 except:
455 return False
456 else:
457 return True
458
459 - def copy_param(self,old_block, old_lha, block=None, lhacode=None):
460 """ make a parameter, a symbolic link on another one """
461
462
463 old_block_obj = self[old_block]
464 parameter = old_block_obj.get(old_lha)
465 if not block:
466 block = old_block
467 if not lhacode:
468 lhacode = old_lha
469
470 self.add_param(block, lhacode, parameter.value, parameter.comment)
471
472 - def add_param(self,block, lha, value, comment=''):
473
474 parameter = Parameter(block=block, lhacode=lha, value=value,
475 comment=comment)
476 try:
477 new_block = self[block]
478 except KeyError:
479
480 new_block = Block(block)
481 self.append(new_block)
482 new_block.append(parameter)
483
484
485 - def mod_param(self, old_block, old_lha, block=None, lhacode=None,
486 value=None, comment=None):
487 """ change a parameter to a new one. This is not a duplication."""
488
489
490 old_block = self[old_block]
491 try:
492 parameter = old_block.get(old_lha)
493 except:
494 if lhacode is not None:
495 lhacode=old_lha
496 self.add_param(block, lhacode, value, comment)
497 return
498
499
500
501 if block:
502 parameter.lhablock = block
503 if lhacode:
504 parameter.lhacode = lhacode
505 if value:
506 parameter.value = value
507 if comment:
508 parameter.comment = comment
509
510
511 if block:
512 old_block.remove(old_lha)
513 if not len(old_block):
514 self.remove_block(old_block.name)
515 try:
516 new_block = self[block]
517 except KeyError:
518
519 new_block = Block(block)
520 self.append(new_block)
521 new_block.append(parameter)
522 elif lhacode:
523 old_block.param_dict[tuple(lhacode)] = \
524 old_block.param_dict.pop(tuple(old_lha))
525
526
528 """ check that the value is coherent and remove it"""
529
530 if self.has_param(block, lhacode):
531 param = self[block].get(lhacode)
532 if param.value != value:
533 error_msg = 'This card is not suitable to be convert to SLAH1\n'
534 error_msg += 'Parameter %s %s should be %s' % (block, lhacode, value)
535 raise InvalidParamCard, error_msg
536 self.remove_param(block, lhacode)
537
540 """ a param Card: list of Block with also MP definition of variables"""
541
543 """ write a fortran file which hardcode the param value"""
544
545 fout = file_writers.FortranWriter(outpath)
546 defaultcard = ParamCard(default)
547 for line in open(identpath):
548 if line.startswith('c ') or line.startswith('ccccc'):
549 continue
550 split = line.split()
551 if len(split) < 3:
552 continue
553 block = split[0]
554 lhaid = [int(i) for i in split[1:-1]]
555 variable = split[-1]
556 if block in self:
557 try:
558 value = self[block].get(tuple(lhaid)).value
559 except KeyError:
560 value =defaultcard[block].get(tuple(lhaid)).value
561 else:
562 value =defaultcard[block].get(tuple(lhaid)).value
563
564 fout.writelines(' %s = %s' % (variable, ('%e' % value).replace('e','d')))
565 fout.writelines(' %s%s = %s_16' % (self.mp_prefix,
566 variable, ('%e' % value)))
567
570 """ A class for storing the linked between the different parameter of
571 the param_card.
572 Able to write a file 'param_card_rule.dat'
573 Able to read a file 'param_card_rule.dat'
574 Able to check the validity of a param_card.dat
575 """
576
577
579 """initialize an object """
580
581
582 self.zero = []
583 self.one = []
584 self.identical = []
585 self.opposite = []
586
587
588 self.rule = []
589
590 if inputpath:
591 self.load_rule(inputpath)
592
593 - def add_zero(self, lhablock, lhacode, comment=''):
594 """add a zero rule"""
595 self.zero.append( (lhablock, lhacode, comment) )
596
597 - def add_one(self, lhablock, lhacode, comment=''):
598 """add a one rule"""
599 self.one.append( (lhablock, lhacode, comment) )
600
601 - def add_identical(self, lhablock, lhacode, lhacode2, comment=''):
602 """add a rule for identical value"""
603 self.identical.append( (lhablock, lhacode, lhacode2, comment) )
604
605 - def add_opposite(self, lhablock, lhacode, lhacode2, comment=''):
606 """add a rule for identical value"""
607 self.opposite.append( (lhablock, lhacode, lhacode2, comment) )
608
609
610 - def add_rule(self, lhablock, lhacode, rule, comment=''):
611 """add a rule for constraint value"""
612 self.rule.append( (lhablock, lhacode, rule) )
613
615
616 text = """<file>######################################################################
617 ## VALIDITY RULE FOR THE PARAM_CARD ####
618 ######################################################################\n"""
619
620
621 text +='<zero>\n'
622 for name, id, comment in self.zero:
623 text+=' %s %s # %s\n' % (name, ' '.join([str(i) for i in id]),
624 comment)
625
626 text +='</zero>\n<one>\n'
627 for name, id, comment in self.one:
628 text+=' %s %s # %s\n' % (name, ' '.join([str(i) for i in id]),
629 comment)
630
631 text +='</one>\n<identical>\n'
632 for name, id,id2, comment in self.identical:
633 text+=' %s %s : %s # %s\n' % (name, ' '.join([str(i) for i in id]),
634 ' '.join([str(i) for i in id2]), comment)
635
636
637 text +='</identical>\n<opposite>\n'
638 for name, id,id2, comment in self.opposite:
639 text+=' %s %s : %s # %s\n' % (name, ' '.join([str(i) for i in id]),
640 ' '.join([str(i) for i in id2]), comment)
641
642
643 text += '</opposite>\n<constraint>\n'
644 for name, id, rule, comment in self.rule:
645 text += ' %s %s : %s # %s\n' % (name, ' '.join([str(i) for i in id]),
646 rule, comment)
647 text += '</constraint>\n</file>'
648
649 if isinstance(output, str):
650 output = open(output,'w')
651 if hasattr(output, 'write'):
652 output.write(text)
653 return text
654
656 """ import a validity rule file """
657
658
659 try:
660 tree = ET.parse(inputpath)
661 except IOError:
662 if '\n' in inputpath:
663
664 tree = ET.fromstring(inputpath)
665 else:
666 raise
667
668
669 element = tree.find('zero')
670 if element is not None:
671 for line in element.text.split('\n'):
672 line = line.split('#',1)[0]
673 if not line:
674 continue
675 lhacode = line.split()
676 blockname = lhacode.pop(0)
677 lhacode = [int(code) for code in lhacode ]
678 self.add_zero(blockname, lhacode, '')
679
680
681 element = tree.find('one')
682 if element is not None:
683 for line in element.text.split('\n'):
684 line = line.split('#',1)[0]
685 if not line:
686 continue
687 lhacode = line.split()
688 blockname = lhacode.pop(0)
689 lhacode = [int(code) for code in lhacode ]
690 self.add_one(blockname, lhacode, '')
691
692
693 element = tree.find('identical')
694 if element is not None:
695 for line in element.text.split('\n'):
696 line = line.split('#',1)[0]
697 if not line:
698 continue
699 line, lhacode2 = line.split(':')
700 lhacode = line.split()
701 blockname = lhacode.pop(0)
702 lhacode = [int(code) for code in lhacode ]
703 lhacode2 = [int(code) for code in lhacode2.split() ]
704 self.add_identical(blockname, lhacode, lhacode2, '')
705
706
707 element = tree.find('opposite')
708 if element is not None:
709 for line in element.text.split('\n'):
710 line = line.split('#',1)[0]
711 if not line:
712 continue
713 line, lhacode2 = line.split(':')
714 lhacode = line.split()
715 blockname = lhacode.pop(0)
716 lhacode = [int(code) for code in lhacode ]
717 lhacode2 = [int(code) for code in lhacode2.split() ]
718 self.add_opposite(blockname, lhacode, lhacode2, '')
719
720
721 element = tree.find('rule')
722 if element is not None:
723 for line in element.text.split('\n'):
724 line = line.split('#',1)[0]
725 if not line:
726 continue
727 line, rule = line.split(':')
728 lhacode = line.split()
729 blockname = lhacode.pop(0)
730 self.add_rule(blockname, lhacode, rule, '')
731
732 @staticmethod
734 """ read a param_card and return a dictionary with the associated value."""
735
736 output = ParamCard(path)
737
738
739
740 return output
741
742 @staticmethod
744 """ read a param_card and return a dictionary with the associated value."""
745
746 output = {}
747
748 if isinstance(path, str):
749 output = open(path, 'w')
750 else:
751 output = path
752
753 data.write(path)
754
755
757 """Check that the restriction card are applied"""
758
759 card = self.read_param_card(path)
760
761
762 for block, id, comment in self.zero:
763 try:
764 value = float(card[block].get(id).value)
765 except KeyError:
766 if modify:
767 new_param = Parameter(block=block,lhacode=id, value=0,
768 comment='fixed by the model')
769 if block in card:
770 card[block].append(new_param)
771 else:
772 new_block = Block(block)
773 card.append(new_block)
774 new_block.append(new_param)
775 else:
776 if value != 0:
777 if not modify:
778 raise InvalidParamCard, 'parameter %s: %s is not at zero' % \
779 (block, ' '.join([str(i) for i in id]))
780 else:
781 param = card[block].get(id)
782 param.value = 0.0
783 param.comment += ' fixed by the model'
784
785
786 for block, id, comment in self.one:
787 try:
788 value = card[block].get(id).value
789 except KeyError:
790 if modify:
791 new_param = Parameter(block=block,lhacode=id, value=1,
792 comment='fixed by the model')
793 if block in card:
794 card[block].append(new_param)
795 else:
796 new_block = Block(block)
797 card.append(new_block)
798 new_block.append(new_param)
799 else:
800 if value != 1:
801 if not modify:
802 raise InvalidParamCard, 'parameter %s: %s is not at one but at %s' % \
803 (block, ' '.join([str(i) for i in id]), value)
804 else:
805 param = card[block].get(id)
806 param.value = 1.0
807 param.comment += ' fixed by the model'
808
809
810
811 for block, id1, id2, comment in self.identical:
812 if block not in card:
813 logger.warning('''Param card is not complete: Block %s is simply missing.
814 We will use model default for all missing value! Please cross-check that
815 this correspond to your expectation.''' % block)
816 continue
817 value2 = float(card[block].get(id2).value)
818 try:
819 param = card[block].get(id1)
820 except KeyError:
821 if modify:
822 new_param = Parameter(block=block,lhacode=id1, value=value2,
823 comment='must be identical to %s' %id2)
824 card[block].append(new_param)
825 else:
826 value1 = float(param.value)
827
828 if value1 != value2:
829 if not modify:
830 raise InvalidParamCard, 'parameter %s: %s is not to identical to parameter %s' % \
831 (block, ' '.join([str(i) for i in id1]),
832 ' '.join([str(i) for i in id2]))
833 else:
834 param = card[block].get(id1)
835 param.value = value2
836 param.comment += ' must be identical to %s' % id2
837
838
839 for block, id1, id2, comment in self.opposite:
840 value2 = float(card[block].get(id2).value)
841 try:
842 param = card[block].get(id1)
843 except KeyError:
844 if modify:
845 new_param = Parameter(block=block,lhacode=id1, value=-value2,
846 comment='must be opposite to to %s' %id2)
847 card[block].append(new_param)
848 else:
849 value1 = float(param.value)
850
851 if value1 != -value2:
852 if not modify:
853 raise InvalidParamCard, 'parameter %s: %s is not to opposite to parameter %s' % \
854 (block, ' '.join([str(i) for i in id1]),
855 ' '.join([str(i) for i in id2]))
856 else:
857 param = card[block].get(id1)
858 param.value = -value2
859 param.comment += ' must be opposite to %s' % id2
860
861 return card
862
865 """ """
866
867 if not outputpath:
868 outputpath = path
869 card = ParamCard(path)
870 if not 'usqmix' in card:
871
872 card.write(outputpath)
873 return
874
875
876
877 card.copy_param('mass', [6], 'sminputs', [6])
878 card.copy_param('mass', [15], 'sminputs', [7])
879 card.copy_param('mass', [23], 'sminputs', [4])
880
881
882
883 card.add_param('modsel',[1], value=1)
884 card['modsel'].get([1]).format = 'int'
885
886
887 scale = card['hmix'].scale
888 if not scale:
889 scale = 1
890
891
892 if not card.has_param('sminputs', [2]):
893 aem1 = card['sminputs'].get([1]).value
894 mz = card['mass'].get([23]).value
895 mw = card['mass'].get([24]).value
896 gf = math.pi / math.sqrt(2) / aem1 * mz**2/ mw**2 /(mz**2-mw**2)
897 card.add_param('sminputs', [2], gf, 'G_F [GeV^-2]')
898
899
900 card.check_and_remove('usqmix', [1,1], 1.0)
901 card.check_and_remove('usqmix', [2,2], 1.0)
902 card.check_and_remove('usqmix', [4,4], 1.0)
903 card.check_and_remove('usqmix', [5,5], 1.0)
904 card.mod_param('usqmix', [3,3], 'stopmix', [1,1])
905 card.mod_param('usqmix', [3,6], 'stopmix', [1,2])
906 card.mod_param('usqmix', [6,3], 'stopmix', [2,1])
907 card.mod_param('usqmix', [6,6], 'stopmix', [2,2])
908
909
910 card.check_and_remove('dsqmix', [1,1], 1.0)
911 card.check_and_remove('dsqmix', [2,2], 1.0)
912 card.check_and_remove('dsqmix', [4,4], 1.0)
913 card.check_and_remove('dsqmix', [5,5], 1.0)
914 card.mod_param('dsqmix', [3,3], 'sbotmix', [1,1])
915 card.mod_param('dsqmix', [3,6], 'sbotmix', [1,2])
916 card.mod_param('dsqmix', [6,3], 'sbotmix', [2,1])
917 card.mod_param('dsqmix', [6,6], 'sbotmix', [2,2])
918
919
920
921 card.check_and_remove('selmix', [1,1], 1.0)
922 card.check_and_remove('selmix', [2,2], 1.0)
923 card.check_and_remove('selmix', [4,4], 1.0)
924 card.check_and_remove('selmix', [5,5], 1.0)
925 card.mod_param('selmix', [3,3], 'staumix', [1,1])
926 card.mod_param('selmix', [3,6], 'staumix', [1,2])
927 card.mod_param('selmix', [6,3], 'staumix', [2,1])
928 card.mod_param('selmix', [6,6], 'staumix', [2,2])
929
930
931 card.mod_param('fralpha', [1], 'alpha', [' '])
932
933
934 if not card.has_param('hmix', [3]):
935 aem1 = card['sminputs'].get([1]).value
936 tanb = card['hmix'].get([2]).value
937 mz = card['mass'].get([23]).value
938 mw = card['mass'].get([24]).value
939 sw = math.sqrt(mz**2 - mw**2)/mz
940 ee = 2 * math.sqrt(1/aem1) * math.sqrt(math.pi)
941 vu = 2 * mw *sw /ee * math.sin(math.atan(tanb))
942 card.add_param('hmix', [3], vu, 'higgs vev(Q) MSSM DRb')
943 card['hmix'].scale= scale
944
945
946 card.check_and_remove('vckm', [1,1], 1.0)
947 card.check_and_remove('vckm', [2,2], 1.0)
948 card.check_and_remove('vckm', [3,3], 1.0)
949
950
951 card.check_and_remove('snumix', [1,1], 1.0)
952 card.check_and_remove('snumix', [2,2], 1.0)
953 card.check_and_remove('snumix', [3,3], 1.0)
954
955
956 card.check_and_remove('upmns', [1,1], 1.0)
957 card.check_and_remove('upmns', [2,2], 1.0)
958 card.check_and_remove('upmns', [3,3], 1.0)
959
960
961 ye = card['ye'].get([3, 3]).value
962 te = card['te'].get([3, 3]).value
963 card.mod_param('te', [3,3], 'ae', [3,3], value= te/ye, comment='A_tau(Q) DRbar')
964 card.add_param('ae', [1,1], 0, 'A_e(Q) DRbar')
965 card.add_param('ae', [2,2], 0, 'A_mu(Q) DRbar')
966 card['ae'].scale = scale
967 card['ye'].scale = scale
968
969
970 yu = card['yu'].get([3, 3]).value
971 tu = card['tu'].get([3, 3]).value
972 card.mod_param('tu', [3,3], 'au', [3,3], value= tu/yu, comment='A_t(Q) DRbar')
973 card.add_param('au', [1,1], 0, 'A_u(Q) DRbar')
974 card.add_param('au', [2,2], 0, 'A_c(Q) DRbar')
975 card['au'].scale = scale
976 card['yu'].scale = scale
977
978
979 yd = card['yd'].get([3, 3]).value
980 td = card['td'].get([3, 3]).value
981 card.mod_param('td', [3,3], 'ad', [3,3], value= td/yd, comment='A_b(Q) DRbar')
982 card.add_param('ad', [1,1], 0, 'A_d(Q) DRbar')
983 card.add_param('ad', [2,2], 0, 'A_s(Q) DRbar')
984 card['ad'].scale = scale
985 card['yd'].scale = scale
986
987
988 value = card['msl2'].get([1, 1]).value
989 card.mod_param('msl2', [1,1], 'msoft', [31], math.sqrt(value))
990 value = card['msl2'].get([2, 2]).value
991 card.mod_param('msl2', [2,2], 'msoft', [32], math.sqrt(value))
992 value = card['msl2'].get([3, 3]).value
993 card.mod_param('msl2', [3,3], 'msoft', [33], math.sqrt(value))
994 card['msoft'].scale = scale
995
996
997 value = card['mse2'].get([1, 1]).value
998 card.mod_param('mse2', [1,1], 'msoft', [34], math.sqrt(value))
999 value = card['mse2'].get([2, 2]).value
1000 card.mod_param('mse2', [2,2], 'msoft', [35], math.sqrt(value))
1001 value = card['mse2'].get([3, 3]).value
1002 card.mod_param('mse2', [3,3], 'msoft', [36], math.sqrt(value))
1003
1004
1005 value = card['msq2'].get([1, 1]).value
1006 card.mod_param('msq2', [1,1], 'msoft', [41], math.sqrt(value))
1007 value = card['msq2'].get([2, 2]).value
1008 card.mod_param('msq2', [2,2], 'msoft', [42], math.sqrt(value))
1009 value = card['msq2'].get([3, 3]).value
1010 card.mod_param('msq2', [3,3], 'msoft', [43], math.sqrt(value))
1011
1012
1013 value = card['msu2'].get([1, 1]).value
1014 card.mod_param('msu2', [1,1], 'msoft', [44], math.sqrt(value))
1015 value = card['msu2'].get([2, 2]).value
1016 card.mod_param('msu2', [2,2], 'msoft', [45], math.sqrt(value))
1017 value = card['msu2'].get([3, 3]).value
1018 card.mod_param('msu2', [3,3], 'msoft', [46], math.sqrt(value))
1019
1020
1021 value = card['msd2'].get([1, 1]).value
1022 card.mod_param('msd2', [1,1], 'msoft', [47], math.sqrt(value))
1023 value = card['msd2'].get([2, 2]).value
1024 card.mod_param('msd2', [2,2], 'msoft', [48], math.sqrt(value))
1025 value = card['msd2'].get([3, 3]).value
1026 card.mod_param('msd2', [3,3], 'msoft', [49], math.sqrt(value))
1027
1028
1029
1030
1031
1032
1033 card.write(outputpath)
1034
1038 """
1039 """
1040
1041 if not outputpath:
1042 outputpath = path
1043 card = ParamCard(path)
1044 if 'usqmix' in card:
1045
1046 if outputpath != path and writting:
1047 card.write(outputpath)
1048 return card
1049
1050
1051
1052 card.remove_param('sminputs', [2])
1053 card.remove_param('sminputs', [4])
1054 card.remove_param('sminputs', [6])
1055 card.remove_param('sminputs', [7])
1056
1057
1058
1059 card.remove_param('modsel',[1])
1060
1061
1062
1063 card.add_param('usqmix', [1,1], 1.0)
1064 card.add_param('usqmix', [2,2], 1.0)
1065 card.add_param('usqmix', [4,4], 1.0)
1066 card.add_param('usqmix', [5,5], 1.0)
1067 card.mod_param('stopmix', [1,1], 'usqmix', [3,3])
1068 card.mod_param('stopmix', [1,2], 'usqmix', [3,6])
1069 card.mod_param('stopmix', [2,1], 'usqmix', [6,3])
1070 card.mod_param('stopmix', [2,2], 'usqmix', [6,6])
1071
1072
1073 card.add_param('dsqmix', [1,1], 1.0)
1074 card.add_param('dsqmix', [2,2], 1.0)
1075 card.add_param('dsqmix', [4,4], 1.0)
1076 card.add_param('dsqmix', [5,5], 1.0)
1077 card.mod_param('sbotmix', [1,1], 'dsqmix', [3,3])
1078 card.mod_param('sbotmix', [1,2], 'dsqmix', [3,6])
1079 card.mod_param('sbotmix', [2,1], 'dsqmix', [6,3])
1080 card.mod_param('sbotmix', [2,2], 'dsqmix', [6,6])
1081
1082
1083
1084 card.add_param('selmix', [1,1], 1.0)
1085 card.add_param('selmix', [2,2], 1.0)
1086 card.add_param('selmix', [4,4], 1.0)
1087 card.add_param('selmix', [5,5], 1.0)
1088 card.mod_param('staumix', [1,1], 'selmix', [3,3])
1089 card.mod_param('staumix', [1,2], 'selmix', [3,6])
1090 card.mod_param('staumix', [2,1], 'selmix', [6,3])
1091 card.mod_param('staumix', [2,2], 'selmix', [6,6])
1092
1093
1094 card.mod_param('alpha', [], 'fralpha', [1])
1095
1096
1097 card.remove_param('hmix', [3])
1098
1099
1100 card.add_param('vckm', [1,1], 1.0)
1101 card.add_param('vckm', [2,2], 1.0)
1102 card.add_param('vckm', [3,3], 1.0)
1103
1104
1105 card.add_param('snumix', [1,1], 1.0)
1106 card.add_param('snumix', [2,2], 1.0)
1107 card.add_param('snumix', [3,3], 1.0)
1108
1109
1110 card.add_param('upmns', [1,1], 1.0)
1111 card.add_param('upmns', [2,2], 1.0)
1112 card.add_param('upmns', [3,3], 1.0)
1113
1114
1115 ye = card['ye'].get([1, 1], default=0).value
1116 ae = card['ae'].get([1, 1], default=0).value
1117 card.mod_param('ae', [1,1], 'te', [1,1], value= ae * ye, comment='T_e(Q) DRbar')
1118 if ae * ye:
1119 raise InvalidParamCard, '''This card is not suitable to be converted to MSSM UFO model
1120 Parameter ae [1, 1] times ye [1,1] should be 0'''
1121 card.remove_param('ae', [1,1])
1122
1123 ye = card['ye'].get([2, 2], default=0).value
1124
1125 ae = card['ae'].get([2, 2], default=0).value
1126 card.mod_param('ae', [2,2], 'te', [2,2], value= ae * ye, comment='T_mu(Q) DRbar')
1127 if ae * ye:
1128 raise InvalidParamCard, '''This card is not suitable to be converted to MSSM UFO model
1129 Parameter ae [2, 2] times ye [2,2] should be 0'''
1130 card.remove_param('ae', [2,2])
1131
1132 ye = card['ye'].get([3, 3], default=0).value
1133 ae = card['ae'].get([3, 3], default=0).value
1134 card.mod_param('ae', [3,3], 'te', [3,3], value= ae * ye, comment='T_tau(Q) DRbar')
1135
1136
1137 yu = card['yu'].get([1, 1], default=0).value
1138 au = card['au'].get([1, 1], default=0).value
1139 card.mod_param('au', [1,1], 'tu', [1,1], value= au * yu, comment='T_u(Q) DRbar')
1140 if au * yu:
1141 raise InvalidParamCard, '''This card is not suitable to be converted to MSSM UFO model
1142 Parameter au [1, 1] times yu [1,1] should be 0'''
1143 card.remove_param('au', [1,1])
1144
1145 ye = card['yu'].get([2, 2], default=0).value
1146
1147 ae = card['au'].get([2, 2], default=0).value
1148 card.mod_param('au', [2,2], 'tu', [2,2], value= au * yu, comment='T_c(Q) DRbar')
1149 if au * yu:
1150 raise InvalidParamCard, '''This card is not suitable to be converted to MSSM UFO model
1151 Parameter au [2, 2] times yu [2,2] should be 0'''
1152 card.remove_param('au', [2,2])
1153
1154 yu = card['yu'].get([3, 3]).value
1155 au = card['au'].get([3, 3]).value
1156 card.mod_param('au', [3,3], 'tu', [3,3], value= au * yu, comment='T_t(Q) DRbar')
1157
1158
1159 yd = card['yd'].get([1, 1], default=0).value
1160 ad = card['ad'].get([1, 1], default=0).value
1161 card.mod_param('ad', [1,1], 'td', [1,1], value= ad * yd, comment='T_d(Q) DRbar')
1162 if ad * yd:
1163 raise InvalidParamCard, '''This card is not suitable to be converted to MSSM UFO model
1164 Parameter ad [1, 1] times yd [1,1] should be 0'''
1165 card.remove_param('ad', [1,1])
1166
1167 ye = card['yd'].get([2, 2], default=0).value
1168
1169 ae = card['ad'].get([2, 2], default=0).value
1170 card.mod_param('ad', [2,2], 'td', [2,2], value= ad * yd, comment='T_s(Q) DRbar')
1171 if ad * yd:
1172 raise InvalidParamCard, '''This card is not suitable to be converted to MSSM UFO model
1173 Parameter ad [2, 2] times yd [2,2] should be 0'''
1174 card.remove_param('ad', [2,2])
1175
1176 yd = card['yd'].get([3, 3]).value
1177 ad = card['ad'].get([3, 3]).value
1178 card.mod_param('ad', [3,3], 'td', [3,3], value= ad * yd, comment='T_b(Q) DRbar')
1179
1180
1181
1182 value = card['msoft'].get([31]).value
1183 card.mod_param('msoft', [31], 'msl2', [1,1], value**2)
1184 value = card['msoft'].get([32]).value
1185 card.mod_param('msoft', [32], 'msl2', [2,2], value**2)
1186 value = card['msoft'].get([33]).value
1187 card.mod_param('msoft', [33], 'msl2', [3,3], value**2)
1188
1189
1190 value = card['msoft'].get([34]).value
1191 card.mod_param('msoft', [34], 'mse2', [1,1], value**2)
1192 value = card['msoft'].get([35]).value
1193 card.mod_param('msoft', [35], 'mse2', [2,2], value**2)
1194 value = card['msoft'].get([36]).value
1195 card.mod_param('msoft', [36], 'mse2', [3,3], value**2)
1196
1197
1198 value = card['msoft'].get([41]).value
1199 card.mod_param('msoft', [41], 'msq2', [1,1], value**2)
1200 value = card['msoft'].get([42]).value
1201 card.mod_param('msoft', [42], 'msq2', [2,2], value**2)
1202 value = card['msoft'].get([43]).value
1203 card.mod_param('msoft', [43], 'msq2', [3,3], value**2)
1204
1205
1206 value = card['msoft'].get([44]).value
1207 card.mod_param('msoft', [44], 'msu2', [1,1], value**2)
1208 value = card['msoft'].get([45]).value
1209 card.mod_param('msoft', [45], 'msu2', [2,2], value**2)
1210 value = card['msoft'].get([46]).value
1211 card.mod_param('msoft', [46], 'msu2', [3,3], value**2)
1212
1213
1214 value = card['msoft'].get([47]).value
1215 card.mod_param('msoft', [47], 'msd2', [1,1], value**2)
1216 value = card['msoft'].get([48]).value
1217 card.mod_param('msoft', [48], 'msd2', [2,2], value**2)
1218 value = card['msoft'].get([49]).value
1219 card.mod_param('msoft', [49], 'msd2', [3,3], value**2)
1220
1221
1222
1223
1224 if writting:
1225 card.write(outputpath)
1226 return card
1227
1230 """ modify the current param_card such that it agrees with the restriction"""
1231
1232 if not outputpath:
1233 outputpath = path
1234
1235 cardrule = ParamCardRule()
1236 cardrule.load_rule(restrictpath)
1237 try :
1238 cardrule.check_param_card(path, modify=False)
1239 except InvalidParamCard:
1240 new_data = cardrule.check_param_card(path, modify=True)
1241 cardrule.write_param_card(outputpath, new_data)
1242 else:
1243 if path != outputpath:
1244 shutil.copy(path, outputpath)
1245 return cardrule
1246
1248 """ check if the current param_card agrees with the restriction"""
1249
1250 if restrictpath is None:
1251 restrictpath = os.path.dirname(path)
1252 restrictpath = os.path.join(restrictpath, os.pardir, os.pardir, 'Source',
1253 'MODEL', 'param_card_rule.dat')
1254 if not os.path.exists(restrictpath):
1255 restrictpath = os.path.dirname(path)
1256 restrictpath = os.path.join(restrictpath, os.pardir, 'Source',
1257 'MODEL', 'param_card_rule.dat')
1258 if not os.path.exists(restrictpath):
1259 return True
1260
1261 cardrule = ParamCardRule()
1262 cardrule.load_rule(restrictpath)
1263 cardrule.check_param_card(path, modify=False)
1264
1265 if '__main__' == __name__:
1266
1267
1268
1269
1270 import sys
1271 args = sys.argv
1272 sys.path.append(os.path.dirname(__file__))
1273 convert_to_slha1(args[1] , args[2])
1274