I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution? Many thanks, Robert
Would it be the case that it is necessary first to assign atom_curves.bcr_approx to the xray_structure.scattering_type_registry() for producing a real space Fcalc map using atomic density profiles at finite resolution? Robert robert＠oeffner.net wrote:
I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution?
Many thanks,
Robert
Hi Rob,
I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution?
one way of doing this is to compute Fcalc using def structure_factors method of xray.structure. This is a finite resolution Fourier map you asking for, which is stored in miller.array object. If you need a real-space equivalent of that, do .fft_map() on that object that will give it to you. The methodology described in the paper you quoted above is coded in cctbx/matpbx/bcr and indeed, this allows to compute finite resolution map directly without first computing Fourier map and then converting it into the real-space map, see cctbx/matpbx/tst_bcr.py for examples. I'm actively working on this to enable real-space refinement of parameters like B factors, occupancies and coordinates using more accurate LS targets rather than simplistic atom-centered functions. So far production code only computes the expansion coefficients and 1D atom map profiles. Soon I will commit actual general case finite resolution map generation code. But for now you can just do the same via Fourier space. Pavel
The only programs I know of that will output the calculated density map before going into reciprocal space are SFALL (CCP4) and the newer "gemmi" from Global Phasing. If there is a direct map rendering tool in Phenix, I'd love to know about it. HTH, -James Holton MAD Scientist On 12/5/2024 11:24 AM, Pavel Afonine wrote:
Hi Rob,
I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution?
one way of doing this is to compute Fcalc using
def structure_factors
method of xray.structure. This is a finite resolution Fourier map you asking for, which is stored in miller.array object. If you need a real-space equivalent of that, do .fft_map() on that object that will give it to you.
The methodology described in the paper you quoted above is coded in cctbx/matpbx/bcr and indeed, this allows to compute finite resolution map directly without first computing Fourier map and then converting it into the real-space map, see
cctbx/matpbx/tst_bcr.py
for examples.
I'm actively working on this to enable real-space refinement of parameters like B factors, occupancies and coordinates using more accurate LS targets rather than simplistic atom-centered functions.
So far production code only computes the expansion coefficients and 1D atom map profiles. Soon I will commit actual general case finite resolution map generation code.
But for now you can just do the same via Fourier space.
Pavel
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
Hi James, This has been available for as long as CCTBX/Phenix have existed—in my memory, for 20+ years, for sure. This: phenix.fmodel model.pdb high_res=2 will give you a 2 Å resolution Fourier map of model.pdb from model.pdb, and this: phenix.fmodel model.pdb reflections.mtz will give you a Fourier map of model.pdb that corresponds to the HKL found in reflections.mtz. Now, if you're looking for a real-space map, this: phenix.fft will convert the Fourier map generated with the above commands into that map. Of course, I assume someone with your level of expertise will do all of this in a Python script using CCTBX — at least for more flexibility and fun! All the best, Pavel On 12/5/24 11:50, James Holton wrote:
The only programs I know of that will output the calculated density map before going into reciprocal space are SFALL (CCP4) and the newer "gemmi" from Global Phasing. If there is a direct map rendering tool in Phenix, I'd love to know about it.
HTH,
-James Holton MAD Scientist
On 12/5/2024 11:24 AM, Pavel Afonine wrote:
Hi Rob,
I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution?
one way of doing this is to compute Fcalc using
def structure_factors
method of xray.structure. This is a finite resolution Fourier map you asking for, which is stored in miller.array object. If you need a real-space equivalent of that, do .fft_map() on that object that will give it to you.
The methodology described in the paper you quoted above is coded in cctbx/matpbx/bcr and indeed, this allows to compute finite resolution map directly without first computing Fourier map and then converting it into the real-space map, see
cctbx/matpbx/tst_bcr.py
for examples.
I'm actively working on this to enable real-space refinement of parameters like B factors, occupancies and coordinates using more accurate LS targets rather than simplistic atom-centered functions.
So far production code only computes the expansion coefficients and 1D atom map profiles. Soon I will commit actual general case finite resolution map generation code.
But for now you can just do the same via Fourier space.
Pavel
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
Hey Pavel, What I'm talking about is making a map from a PDB without having to do two FFTs. Just plot electrons/A^3 on a real space grid based on the atomic form factors, and then output rho vs x,y,z. A nice thing about such maps is that rho=0 means vacuum. This makes things like subsequent masking and other real-space manipulations cleaner. There are also no "ripples" around all the atoms due to series-termination. Yes, these ripples can be made small, but they are not zero. Not after an FFT. And besides, skipping the FFT is faster! I know that phenix has a long-standing philosophy of only dealing with maps as their reciprocal-space coefficients. I guess you are calling that a "Fourier map" ? There is nothing intrinsically wrong with that in principle, but you just miss out on things like the happy maps in my happy/sad map demo: https://www.jiscmail.ac.uk/cgi-bin/wa-jisc.exe?A2=ind2304&L=CCP4BB&P=R186499 Just my two cents, -James On 12/5/2024 1:46 PM, Pavel Afonine wrote:
Hi James,
This has been available for as long as CCTBX/Phenix have existed—in my memory, for 20+ years, for sure.
This:
phenix.fmodel model.pdb high_res=2
will give you a 2 Å resolution Fourier map of model.pdb from model.pdb, and
this:
phenix.fmodel model.pdb reflections.mtz
will give you a Fourier map of model.pdb that corresponds to the HKL found in reflections.mtz.
Now, if you're looking for a real-space map,
this:
phenix.fft
will convert the Fourier map generated with the above commands into that map.
Of course, I assume someone with your level of expertise will do all of this in a Python script using CCTBX — at least for more flexibility and fun!
All the best, Pavel
On 12/5/24 11:50, James Holton wrote:
The only programs I know of that will output the calculated density map before going into reciprocal space are SFALL (CCP4) and the newer "gemmi" from Global Phasing. If there is a direct map rendering tool in Phenix, I'd love to know about it.
HTH,
-James Holton MAD Scientist
On 12/5/2024 11:24 AM, Pavel Afonine wrote:
Hi Rob,
I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution?
one way of doing this is to compute Fcalc using
def structure_factors
method of xray.structure. This is a finite resolution Fourier map you asking for, which is stored in miller.array object. If you need a real-space equivalent of that, do .fft_map() on that object that will give it to you.
The methodology described in the paper you quoted above is coded in cctbx/matpbx/bcr and indeed, this allows to compute finite resolution map directly without first computing Fourier map and then converting it into the real-space map, see
cctbx/matpbx/tst_bcr.py
for examples.
I'm actively working on this to enable real-space refinement of parameters like B factors, occupancies and coordinates using more accurate LS targets rather than simplistic atom-centered functions.
So far production code only computes the expansion coefficients and 1D atom map profiles. Soon I will commit actual general case finite resolution map generation code.
But for now you can just do the same via Fourier space.
Pavel
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
Hi James, oh that's what you meant! Then yes, this map is central to most calculations and of course we can compute it and output: phenix.modeL_map model.pdb grid_step=0.3 scattering_table=table_name where table_name can be one of X-ray tables (it1992, wk1995 or n_gaussian) or neutron or electron. This will compute the exact electron density map ('electron' if it is X-ray) and not its finite resolution Fourier image that you'd get with the commands from previous email. Pavel On 12/6/24 11:22, James Holton wrote:
Hey Pavel,
What I'm talking about is making a map from a PDB without having to do two FFTs. Just plot electrons/A^3 on a real space grid based on the atomic form factors, and then output rho vs x,y,z. A nice thing about such maps is that rho=0 means vacuum. This makes things like subsequent masking and other real-space manipulations cleaner. There are also no "ripples" around all the atoms due to series-termination. Yes, these ripples can be made small, but they are not zero. Not after an FFT. And besides, skipping the FFT is faster!
I know that phenix has a long-standing philosophy of only dealing with maps as their reciprocal-space coefficients. I guess you are calling that a "Fourier map" ? There is nothing intrinsically wrong with that in principle, but you just miss out on things like the happy maps in my happy/sad map demo: https://www.jiscmail.ac.uk/cgi-bin/wa-jisc.exe?A2=ind2304&L=CCP4BB&P=R186499
Just my two cents,
-James
On 12/5/2024 1:46 PM, Pavel Afonine wrote:
Hi James,
This has been available for as long as CCTBX/Phenix have existed—in my memory, for 20+ years, for sure.
This:
phenix.fmodel model.pdb high_res=2
will give you a 2 Å resolution Fourier map of model.pdb from model.pdb, and
this:
phenix.fmodel model.pdb reflections.mtz
will give you a Fourier map of model.pdb that corresponds to the HKL found in reflections.mtz.
Now, if you're looking for a real-space map,
this:
phenix.fft
will convert the Fourier map generated with the above commands into that map.
Of course, I assume someone with your level of expertise will do all of this in a Python script using CCTBX — at least for more flexibility and fun!
All the best, Pavel
On 12/5/24 11:50, James Holton wrote:
The only programs I know of that will output the calculated density map before going into reciprocal space are SFALL (CCP4) and the newer "gemmi" from Global Phasing. If there is a direct map rendering tool in Phenix, I'd love to know about it.
HTH,
-James Holton MAD Scientist
On 12/5/2024 11:24 AM, Pavel Afonine wrote:
Hi Rob,
I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution?
one way of doing this is to compute Fcalc using
def structure_factors
method of xray.structure. This is a finite resolution Fourier map you asking for, which is stored in miller.array object. If you need a real-space equivalent of that, do .fft_map() on that object that will give it to you.
The methodology described in the paper you quoted above is coded in cctbx/matpbx/bcr and indeed, this allows to compute finite resolution map directly without first computing Fourier map and then converting it into the real-space map, see
cctbx/matpbx/tst_bcr.py
for examples.
I'm actively working on this to enable real-space refinement of parameters like B factors, occupancies and coordinates using more accurate LS targets rather than simplistic atom-centered functions.
So far production code only computes the expansion coefficients and 1D atom map profiles. Soon I will commit actual general case finite resolution map generation code.
But for now you can just do the same via Fourier space.
Pavel
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
Wow! I never knew that was there! Thanks! -James On 12/6/2024 2:50 PM, Pavel Afonine wrote:
Hi James,
oh that's what you meant! Then yes, this map is central to most calculations and of course we can compute it and output:
phenix.modeL_map model.pdb grid_step=0.3 scattering_table=table_name
where table_name can be one of X-ray tables (it1992, wk1995 or n_gaussian) or neutron or electron.
This will compute the exact electron density map ('electron' if it is X-ray) and not its finite resolution Fourier image that you'd get with the commands from previous email.
Pavel
On 12/6/24 11:22, James Holton wrote:
Hey Pavel,
What I'm talking about is making a map from a PDB without having to do two FFTs. Just plot electrons/A^3 on a real space grid based on the atomic form factors, and then output rho vs x,y,z. A nice thing about such maps is that rho=0 means vacuum. This makes things like subsequent masking and other real-space manipulations cleaner. There are also no "ripples" around all the atoms due to series-termination. Yes, these ripples can be made small, but they are not zero. Not after an FFT. And besides, skipping the FFT is faster!
I know that phenix has a long-standing philosophy of only dealing with maps as their reciprocal-space coefficients. I guess you are calling that a "Fourier map" ? There is nothing intrinsically wrong with that in principle, but you just miss out on things like the happy maps in my happy/sad map demo: https://www.jiscmail.ac.uk/cgi-bin/wa-jisc.exe?A2=ind2304&L=CCP4BB&P=R186499
Just my two cents,
-James
On 12/5/2024 1:46 PM, Pavel Afonine wrote:
Hi James,
This has been available for as long as CCTBX/Phenix have existed—in my memory, for 20+ years, for sure.
This:
phenix.fmodel model.pdb high_res=2
will give you a 2 Å resolution Fourier map of model.pdb from model.pdb, and
this:
phenix.fmodel model.pdb reflections.mtz
will give you a Fourier map of model.pdb that corresponds to the HKL found in reflections.mtz.
Now, if you're looking for a real-space map,
this:
phenix.fft
will convert the Fourier map generated with the above commands into that map.
Of course, I assume someone with your level of expertise will do all of this in a Python script using CCTBX — at least for more flexibility and fun!
All the best, Pavel
On 12/5/24 11:50, James Holton wrote:
The only programs I know of that will output the calculated density map before going into reciprocal space are SFALL (CCP4) and the newer "gemmi" from Global Phasing. If there is a direct map rendering tool in Phenix, I'd love to know about it.
HTH,
-James Holton MAD Scientist
On 12/5/2024 11:24 AM, Pavel Afonine wrote:
Hi Rob,
I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution?
one way of doing this is to compute Fcalc using
def structure_factors
method of xray.structure. This is a finite resolution Fourier map you asking for, which is stored in miller.array object. If you need a real-space equivalent of that, do .fft_map() on that object that will give it to you.
The methodology described in the paper you quoted above is coded in cctbx/matpbx/bcr and indeed, this allows to compute finite resolution map directly without first computing Fourier map and then converting it into the real-space map, see
cctbx/matpbx/tst_bcr.py
for examples.
I'm actively working on this to enable real-space refinement of parameters like B factors, occupancies and coordinates using more accurate LS targets rather than simplistic atom-centered functions.
So far production code only computes the expansion coefficients and 1D atom map profiles. Soon I will commit actual general case finite resolution map generation code.
But for now you can just do the same via Fourier space.
Pavel
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
_______________________________________________ cctbxbb mailing list -- [email protected] To unsubscribe send an email to [email protected]
Thanks a lot for the information, Pavel. Rob On 05/12/2024 19:24, Pavel Afonine wrote:
Hi Rob,
I came across this article https://doi.org/10.1107/S160057672201144X. Although I have yet to read it in details I wonder if the CCTBX can Fcalc maps at finite resolution, i.e. not using Gaussian atomic density profiles. It looks like the function in cctbx.maptbx.atom_curves.bcr_approx(...) is suited to do so. If so, how would I use this for generating a real space map as in https://cci.lbl.gov/docs/cctbx/script_1/#create-a-map-from-a-pdb-file but now using atomic density profiles at finite resolution?
one way of doing this is to compute Fcalc using
def structure_factors
method of xray.structure. This is a finite resolution Fourier map you asking for, which is stored in miller.array object. If you need a real-space equivalent of that, do .fft_map() on that object that will give it to you.
The methodology described in the paper you quoted above is coded in cctbx/matpbx/bcr and indeed, this allows to compute finite resolution map directly without first computing Fourier map and then converting it into the real-space map, see
cctbx/matpbx/tst_bcr.py
for examples.
I'm actively working on this to enable real-space refinement of parameters like B factors, occupancies and coordinates using more accurate LS targets rather than simplistic atom-centered functions.
So far production code only computes the expansion coefficients and 1D atom map profiles. Soon I will commit actual general case finite resolution map generation code.
But for now you can just do the same via Fourier space.
Pavel
-- Robert Oeffner 15 Bayford Place Cambridge, CB4 2UF Tel: +44 (0)7712 887 162
participants (4)
-
James Holton -
Pavel Afonine -
Robert Oeffner -
robert＠oeffner.net