def test_exchangeSPSD_BrinkBoeker_off_diag(self):
att = AttributeArgs.ForceArgs.Brink_Boeker
self.force = switchMatrixElementType(ForceEnum.Brink_Boeker)
self.force_kwargs = {
SHO_Parameters.b_length: 1,
BrinkBoekerParameters.mu_length: {
att.part_1: 0.6,
att.part_2: 1.2
},
BrinkBoekerParameters.Wigner: {
att.part_1: 100,
att.part_2: -50
},
BrinkBoekerParameters.Majorana: {
att.part_1: -50,
att.part_2: -50
},
BrinkBoekerParameters.Heisenberg: {
att.part_1: -50,
att.part_2: -50
},
BrinkBoekerParameters.Bartlett: {
att.part_1: 100,
att.part_2: -50
}
}
sts = tuple([
*valenceSpacesDict['S'], *valenceSpacesDict['P'],
*valenceSpacesDict['SD']
])
self._evaluateSingleParticleStates(sts)
def test_paritySPSD_BrinkBoeker_diagonal(self):
self.force = switchMatrixElementType(ForceEnum.Brink_Boeker)
att = AttributeArgs.ForceArgs.Brink_Boeker
self.force_kwargs = {
SHO_Parameters.b_length: 1,
BrinkBoekerParameters.mu_length: {
att.part_1: 0.6,
att.part_2: 1.2
},
BrinkBoekerParameters.Wigner: {
att.part_1: 100,
att.part_2: -50
},
BrinkBoekerParameters.Majorana: {
att.part_1: -50,
att.part_2: -50
},
BrinkBoekerParameters.Heisenberg: {
att.part_1: -50,
att.part_2: -50
},
BrinkBoekerParameters.Bartlett: {
att.part_1: 100,
att.part_2: -50
}
}
for shell in ('S', 'P', 'SD'):
sts = tuple([*valenceSpacesDict[shell]])
self._evaluateParityConservationOfMatrixElements(sts)
def run(self):
"""
Calculate all the matrix elements for all the interactions, and
print its combination in a file.
"""
self._defineValenceSpaceEnergies()
self._sortQQNNFromTheValenceSpace()
self._checkHamilTypeAndForces()
_forcesAttr = ip.Force_Parameters
times_ = {}
for force, force_list in getattr(self.input_obj, _forcesAttr).items():
i = 0
for params in force_list:
force_str = force + str(i) if len(force_list) > 1 else force
# update arrays and variables
i += 1
self.results = {}
self._forceNameFromForceEnum[force_str] = force
tic_ = time.time()
if force == ForceEnum.Force_From_File:
## read from file case
self._readMatrixElementsFromFile(force_str, **params)
times_[force_str] = round(time.time() - tic_, 4)
continue
## computable interaction
try:
sho_params = getattr(self.input_obj, ip.SHO_Parameters)
self.tbme_class = switchMatrixElementType(force)
self.tbme_class.resetInteractionParameters(also_SHO=True)
self.tbme_class.setInteractionParameters(
**params, **sho_params)
self._computeForValenceSpace(force)
self.resultsByInteraction[force_str] = deepcopy(
self.results)
times_[force_str] = round(time.time() - tic_, 4)
print(" Force [{}] m.e. calculated: [{}]s".format(
force, times_[force_str]))
except BaseException:
trace = traceback.format_exc()
self._procedureToSkipBrokenInteraction(force_str, trace)
print("Finished computation, Total time (s): [", sum(times_.values()),
"]=")
print("\n".join(["\t" + str(t) + "s" for t in times_.items()]))
if len(self._brokeInteractions) > 0:
print(
_LINE_1, "ERROR !! Interactions have errors"
" and where skipped with these exceptions")
for f, excep in self._brokeInteractions.items():
print("Interaction [{}], Exception ::\n{}\n{}".format(
f, excep, _LINE_2))
self.combineAllResults()
self.printMatrixElementsFile()
self.printComMatrixElements()
def test_paritySPSD_ShortRangeLS_diagonal(self):
self.force = switchMatrixElementType(ForceEnum.SpinOrbitShortRange)
self.force_kwargs = {
SHO_Parameters.b_length: 1,
CentralMEParameters.constant: 1,
CentralMEParameters.potential: PotentialForms.Power,
CentralMEParameters.mu_length: 1
}
for shell in ('S', 'P', 'SD'):
sts = tuple([*valenceSpacesDict[shell]])
self._evaluateParityConservationOfMatrixElements(sts)
def test_exchangeSPSD_ShortRangeLS_diagonal(self):
self.force = switchMatrixElementType(ForceEnum.SpinOrbitShortRange)
self.force_kwargs = {
SHO_Parameters.b_length: 1,
CentralMEParameters.constant: 1,
CentralMEParameters.potential: PotentialForms.Power,
CentralMEParameters.mu_length: 1
}
for shell in ('S', 'P', 'SD'):
spss = tuple([*valenceSpacesDict[shell]])
self._evaluateSingleParticleStates(spss)
def test_exchangeSPSD_Kinetic2Body(self):
self.force = switchMatrixElementType(ForceEnum.Kinetic_2Body)
self.force_kwargs = {
SHO_Parameters.b_length: 1,
SHO_Parameters.A_Mass: 8
}
sts = tuple([
*valenceSpacesDict['S'], *valenceSpacesDict['PF'],
*valenceSpacesDict['SD']
])
self._evaluateSingleParticleStates(sts)
def test_paritySPSD_Kinetic2Body(self):
self.force = switchMatrixElementType(ForceEnum.Kinetic_2Body)
self.force_kwargs = {
SHO_Parameters.b_length: 1,
SHO_Parameters.A_Mass: 8
}
sts = tuple([
*valenceSpacesDict['S'], *valenceSpacesDict['PF'],
*valenceSpacesDict['SD']
])
self._evaluateParityConservationOfMatrixElements(sts)
def test_paritySPSD_SpinOrbit(self):
self.force = switchMatrixElementType(ForceEnum.SpinOrbit)
self.force_kwargs = {
SHO_Parameters.b_length: 1,
CentralMEParameters.constant: 1,
CentralMEParameters.potential: PotentialForms.Power,
CentralMEParameters.mu_length: 1,
}
sts = tuple([
*valenceSpacesDict['S'], *valenceSpacesDict['P'],
*valenceSpacesDict['SD']
])
self._evaluateParityConservationOfMatrixElements(sts)
def test_exchangeSPSD_ShortRangeLS_off_diag(self):
self.force = switchMatrixElementType(ForceEnum.SpinOrbitShortRange)
self.force_kwargs = {
SHO_Parameters.b_length: 1,
CentralMEParameters.constant: 1,
CentralMEParameters.potential: PotentialForms.Power,
CentralMEParameters.mu_length: 1
}
sts = tuple([
*valenceSpacesDict['S'], *valenceSpacesDict['P'],
*valenceSpacesDict['SD']
])
self._evaluateSingleParticleStates(sts)
def test_exchangeSPSD_DensityDependant(self):
self.force = switchMatrixElementType(ForceEnum.Density_Dependent)
self.force_kwargs = {
SHO_Parameters.b_length: 1,
SHO_Parameters.A_Mass: 8,
DensityDependentParameters.constant: 1,
CentralMEParameters.potential: PotentialForms.Power,
CentralMEParameters.mu_length: 1,
DensityDependentParameters.alpha: 1 / 3,
DensityDependentParameters.x0: 1,
}
sts = tuple([
*valenceSpacesDict['S'], *valenceSpacesDict['P'],
*valenceSpacesDict['SD']
])
self._evaluateSingleParticleStates(sts)
def _setForces(self):
""" Set the properties of the m.e. classes:
Explicit Antisymmetrization_, Scheme
and instance the auxiliary lists to put the L/S quantum numbers, norms ...
"""
_forcesAttr = ip.Force_Parameters
sho_params = getattr(self.input_obj, ip.SHO_Parameters)
for force, force_list in getattr(self.input_obj, _forcesAttr).items():
if len(force_list) > 1:
## Verify forces do not repeat
if force == ForceEnum.Force_From_File:
for i, params in enumerate(force_list):
force_str = force + str(i)
## read from file case
self._readMatrixElementsFromFile(force_str, **params)
continue ## skip the rest of the steps
else:
raise TBME_SpdRunnerException("Cannot compute two times "
"the same interaction: [{}] len={}".format(force,
len(force_list)))
self.forces.append(switchMatrixElementType(force))
## define interactions
self._allForcesAreLS *= self.forces[-1].RECOUPLES_LS
self.forcesDict[force] = len(self.forces) - 1
self.forces[-1].setInteractionParameters(**force_list[0], **sho_params)
self.forcesIsAntisym.append(self.forces[-1].EXPLICIT_ANTISYMM)
if self.forces[-1].COUPLING == CouplingSchemeEnum.JJ:
self.forcesScheme.append(self._Scheme.J)
dim_t = 6
else:
self.forcesScheme.append(self._Scheme.JT)
dim_t = 2
self.me_instances.append([None]*dim_t)
self.valid_L_forKets.append([None]*dim_t)
self.valid_S_forKets.append([None]*dim_t)
self.forcesNorms.append([None]*dim_t)
def testOrthonormalityOfMoshinskyTransformation(self):
self.force = switchMatrixElementType(ForceEnum.Central)
force_kwargs = {
SHO_Parameters.b_length: 1.5,
CentralMEParameters.mu_length: 0,
CentralMEParameters.potential: PotentialForms.Power,
CentralMEParameters.constant: 1.0,
CentralMEParameters.n_power: 0
}
self.force.setInteractionParameters(**force_kwargs)
sts = tuple([
*valenceSpacesDict['S'], *valenceSpacesDict['P'],
*valenceSpacesDict['SD'], *valenceSpacesDict['PF']
])
for i in range(len(sts)):
a = QN_1body_jj(*readAntoine(sts[i]))
for j in range(i, len(sts)):
b = QN_1body_jj(*readAntoine(sts[j]))
for k in range(j, len(sts)):
c = QN_1body_jj(*readAntoine(sts[k]))
for l in range(k, len(sts)):
d = QN_1body_jj(*readAntoine(sts[l]))
self._testOrthogonality(a, b, c, d)
if len(self.failures) > 0:
print("FAILURES in Orthonormalization test:")
for fail in self.failures:
print(fail)
self.assertEqual(
len(self.failures), 0,
"there are [{}] non orthogonal m.e (TOL={})".format(
len(self.failures), self.TOLERANCE))
def _checkHamilTypeAndForces(self):
"""
Certain interactions cannot be expressed in JT formalism if they break
isospin_ symmetry (f.e Coulomb_). That means the global scheme for the
matrix elements must be J-scheme, and then, only hamilType=3/4 are
accepted to print the elements.
This method checks that if HamilType is 0/1, then it must not be any
isospin_ breaking interactions (before any calculations).
Also fill the interaction schemes.
If com correction, add to the
"""
_forcesAttr = ip.Force_Parameters
J_schemeForces = []
JT_schemeForces = []
T_breaking = []
self._forces2ReadFromFile = False
for force in getattr(self.input_obj, _forcesAttr):
me = switchMatrixElementType(force)
if me._BREAK_ISOSPIN: # cannot use property, m.e. not instanced
T_breaking.append(force)
f_scheme = me.COUPLING
f_scheme = [
f_scheme,
] if isinstance(f_scheme, str) else f_scheme
if CouplingSchemeEnum.L in f_scheme or CouplingSchemeEnum.S in f_scheme:
raise TBME_RunnerException(
"Matrix Element in L or S scheme,"
"class can only run in J or JT scheme")
if (CouplingSchemeEnum.JJ in f_scheme):
if force == ForceEnum.Force_From_File:
self._forces2ReadFromFile = True
continue
elif force == ForceEnum.Kinetic_2Body:
print(self.__advertence_Kin2Body)
self._com_correction = True
continue
if (CouplingSchemeEnum.T in f_scheme):
JT_schemeForces.append(force)
self.interactionSchemes[force] = self._Scheme.JT
if me._BREAK_ISOSPIN:
raise TBME_RunnerException(
"Error in force [{}] <class>:[{}] definition".
format(force, me.__class__.__name__) +
", Isospin based (reduced) matrix elements breaks T."
)
else:
J_schemeForces.append(force)
self.interactionSchemes[force] = self._Scheme.J
if self._com_correction:
# append the K 2Body to the input force to compute (remove after)
getattr(self.input_obj,
_forcesAttr)[ForceEnum.Kinetic_2Body] = [dict()]
JT_schemeForces.append(ForceEnum.Kinetic_2Body)
self.interactionSchemes[ForceEnum.Kinetic_2Body] = self._Scheme.JT
if self._hamil_type in '12':
if len(T_breaking) > 0:
raise TBME_RunnerException(
"Cannot compute isospin-breaking interactions"
"{} to write in hamilType format 1-2 (JT scheme)".format(
T_breaking))
if len(JT_schemeForces) == 0 and (not self._forces2ReadFromFile):
# TODO: might convert to JT scheme J forces.
raise TBME_RunnerException("Cannot compute J forces JT scheme")
